Merge branch '0.9.2' of https://github.com/iMoonLab/DeepHypergraph into 0.9.2

Author: JasonYanjl

dhg/utils/structure.py

@@ -65,6 +65,7 @@ def remap_edge_list(
         ``bipartite_graph`` (``bool``): Whether the structure is bipartite graph. Defaults to ``False``.
         ``ret_map`` (``bool``): Whether to return the map dictionary of raw marker to new index. Defaults to ``False``.
     """
+    e_list = [[str(v) for v in e] for e in e_list]
     if bipartite_graph:
         u_set, v_set = set(), set()
         for u, v in e_list:
@@ -87,7 +88,7 @@ def remap_edge_list(
                 v_set.add(v)
         v_list = sorted(v_set)
         v_map = {raw_v: new_v for new_v, raw_v in enumerate(v_list)}
-        e_list = [set([v_map[v] for v in e]) for e in e_list]
+        e_list = [tuple([v_map[v] for v in e]) for e in e_list]
         if ret_map:
             return e_list, v_map
         else:
@@ -107,6 +108,7 @@ def remap_edge_lists(
         ``bipartite_graph`` (``bool``): Whether the structure is bipartite graph. Defaults to ``False``.
         ``ret_map`` (``bool``): Whether to return the map dictionary of raw marker to new index. Defaults to ``False``.
     """
+    e_lists = [[[str(v) for v in e] for e in e_list] for e_list in e_lists]
     if bipartite_graph:
         u_set, v_set = set(), set()
         for e_list in e_lists:
@@ -131,7 +133,7 @@ def remap_edge_lists(
                     v_set.add(v)
         v_list = sorted(v_set)
         v_map = {raw_v: new_v for new_v, raw_v in enumerate(v_list)}
-        e_list = [[set([v_map[v] for v in e]) for e in e_list] for e_list in e_lists]
+        e_list = [[tuple([v_map[v] for v in e]) for e in e_list] for e_list in e_lists]
         if ret_map:
             return e_list, v_map
         else:
@@ -151,6 +153,7 @@ def remap_adj_list(
         ``bipartite_graph`` (``bool``): Whether the structure is bipartite graph. Defaults to ``False``.
         ``ret_map`` (``bool``): Whether to return the map dictionary of raw marker to new index. Defaults to ``False``.
     """
+    adj_list = [[str(v) for v in line] for line in adj_list]
     if bipartite_graph:
         u_set, v_set = set(), set()
         for line in adj_list:
@@ -202,6 +205,7 @@ def remap_adj_lists(
         ``bipartite_graph`` (``bool``): Whether the structure is bipartite graph. Defaults to ``False``.
         ``ret_map`` (``bool``): Whether to return the map dictionary of raw marker to new index. Defaults to ``False``.
     """
+    adj_lists = [[[str(v) for v in line] for line in adj_list] for adj_list in adj_lists]
     if bipartite_graph:
         u_set, v_set = set(), set()
         for adj_list in adj_lists:

tests/datapipe/test_loaders.py

@@ -4,15 +4,12 @@
 
 
 def test_load_from_txt(tmp_path):
-    origin = [
-        [0, 1, 2],
-        [3, 4],
-        [5, 6, 7, 8]
-    ]
-    with open(tmp_path, 'w') as f:
+    tmp_file_name = tmp_path / "test_load_from_txt.txt"
+    origin = [[0, 1, 2], [3, 4], [5, 6, 7, 8]]
+    with open(tmp_file_name, "w") as f:
         for ori in origin:
-            f.write(' '.join(map(str, ori)) + '\n')
-    data = load_from_txt(tmp_path)
+            f.write(" ".join(map(str, ori)) + "\n")
+    data = load_from_txt(tmp_file_name, "int")
     for ori, dat in zip(origin, data):
         for a, b in zip(ori, dat):
             assert a == b

tests/metrics/test_classification.py

@@ -1,6 +1,7 @@
 import pytest
 
 import torch
+import numpy as np
 from sklearn.metrics import f1_score, confusion_matrix
 import dhg.metrics.classification as dm
 

tests/structure/test_hypergraph.py

@@ -236,6 +236,7 @@ def test_add_hyperedges_from_bigraph():
     assert (0, 1) in h.e_of_group("bigraph-v")[0]
     assert (0, 2) in h.e_of_group("bigraph-v")[0]
 
+
 def test_remove_hyperedges(g1):
     assert g1.e[0] == [(0, 1, 2, 5), (0, 1), (2, 3, 4)]
     assert g1.e[1] == [1, 1, 1]
@@ -580,13 +581,12 @@ def test_smoothing():
     assert pytest.approx(g.smoothing(x, L, lbd)) == x + lbd * L @ x
 
 
-
 def test_L_sym(g1):
     H = g1.H.to_dense().cpu()
     D_v_neg_1_2 = torch.diag(H.sum(dim=1).view(-1) ** (-0.5))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e.to_dense()
-    L_sym = torch.eye(H.shape[0]) -  D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
+    L_sym = torch.eye(H.shape[0]) - D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
     assert (L_sym == g1.L_sym.to_dense().cpu()).all()
 
 
@@ -597,32 +597,32 @@ def test_L_sym_group(g1):
     D_v_neg_1_2 = torch.diag(H.sum(dim=1).view(-1) ** (-0.5))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e.to_dense()
-    L_sym = torch.eye(H.shape[0]) -  D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
+    L_sym = torch.eye(H.shape[0]) - D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
     assert (L_sym == g1.L_sym.to_dense().cpu()).all()
     # main group
     H = g1.H_of_group("main").to_dense().cpu()
     D_v_neg_1_2 = torch.diag(H.sum(dim=1).view(-1) ** (-0.5))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e_of_group("main").to_dense()
-    L_sym = torch.eye(H.shape[0]) -  D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
-    assert (L_sym == g1.L_sym_of_group('main').to_dense().cpu()).all()
+    L_sym = torch.eye(H.shape[0]) - D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
+    assert (L_sym == g1.L_sym_of_group("main").to_dense().cpu()).all()
     # knn group
     H = g1.H_of_group("knn").to_dense().cpu()
     D_v_neg_1_2 = H.sum(dim=1).view(-1) ** (-0.5)
     D_v_neg_1_2[torch.isinf(D_v_neg_1_2)] = 0
     D_v_neg_1_2 = torch.diag(D_v_neg_1_2)
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e_of_group("knn").to_dense()
-    L_sym = torch.eye(H.shape[0]) -  D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
-    assert (L_sym == g1.L_sym_of_group('knn').to_dense().cpu()).all()
+    L_sym = torch.eye(H.shape[0]) - D_v_neg_1_2 @ H @ W_e @ D_e_neg_1 @ H.t() @ D_v_neg_1_2
+    assert (L_sym == g1.L_sym_of_group("knn").to_dense().cpu()).all()
 
 
 def test_L_rw(g1):
     H = g1.H.to_dense().cpu()
     D_v_neg_1 = torch.diag(H.sum(dim=1).view(-1) ** (-1))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e.to_dense()
-    L_rw = torch.eye(H.shape[0]) -  D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
+    L_rw = torch.eye(H.shape[0]) - D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
     assert (L_rw == g1.L_rw.to_dense().cpu()).all()
 
 
@@ -633,24 +633,24 @@ def test_L_rw_group(g1):
     D_v_neg_1 = torch.diag(H.sum(dim=1).view(-1) ** (-1))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e.to_dense()
-    L_rw = torch.eye(H.shape[0]) -  D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
+    L_rw = torch.eye(H.shape[0]) - D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
     assert (L_rw == g1.L_rw.to_dense().cpu()).all()
     # main group
     H = g1.H_of_group("main").to_dense().cpu()
     D_v_neg_1 = torch.diag(H.sum(dim=1).view(-1) ** (-1))
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e_of_group("main").to_dense()
-    L_rw = torch.eye(H.shape[0]) -  D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
-    assert (L_rw == g1.L_rw_of_group('main').to_dense().cpu()).all()
+    L_rw = torch.eye(H.shape[0]) - D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
+    assert (L_rw == g1.L_rw_of_group("main").to_dense().cpu()).all()
     # knn group
     H = g1.H_of_group("knn").to_dense().cpu()
     D_v_neg_1 = H.sum(dim=1).view(-1) ** (-1)
     D_v_neg_1[torch.isinf(D_v_neg_1)] = 0
     D_v_neg_1 = torch.diag(D_v_neg_1)
     D_e_neg_1 = torch.diag(H.sum(dim=0).view(-1) ** (-1))
     W_e = g1.W_e_of_group("knn").to_dense()
-    L_rw = torch.eye(H.shape[0]) -  D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
-    assert (L_rw == g1.L_rw_of_group('knn').to_dense().cpu()).all()
+    L_rw = torch.eye(H.shape[0]) - D_v_neg_1 @ H @ W_e @ D_e_neg_1 @ H.t()
+    assert (L_rw == g1.L_rw_of_group("knn").to_dense().cpu()).all()
 
 
 def test_smoothing_with_HGNN(g1):

tests/utils/test_sparse.py

@@ -5,7 +5,7 @@
 
 
 def test_sparse_dropout():
-    a = torch.rand(10, 20)
+    a = (torch.rand(10, 20) > 0.7).float()
 
     idx = torch.nonzero(a).T
     data = a[idx[0], idx[1]]
@@ -15,7 +15,7 @@ def test_sparse_dropout():
 
     assert coo.size() == dropped.size()
 
-    assert dropped._nnz() == pytest.approx(coo._nnz() * 0.7, 0.1)
+    assert (dropped._values()!=0).sum() == pytest.approx(coo._nnz() * 0.7, 0.15)
 
     for i in range(10):
         for j in range(20):

tests/utils/test_split.py

@@ -26,20 +26,34 @@ def test_split_by_ratio():
     v_label = np.random.randint(0, 10, n)
     r_train, r_val, r_test = 0.5, 0.2, 0.1
     m_train, m_val, m_test = split_by_ratio(n, v_label, r_train, r_val, r_test)
-    assert m_train.sum() == 500
-    assert m_val.sum() == 200
-    assert m_test.sum() == 100
+    assert pytest.approx(m_train.sum(), 5) == 500
+    assert pytest.approx(m_val.sum(), 5) == 200
+    assert pytest.approx(m_test.sum(), 5) == 100
 
     m_train, m_val, m_test = split_by_ratio(n, v_label, r_train, r_val)
-    assert m_train.sum() == 500
-    assert m_val.sum() == 200
-    assert m_test.sum() == 300
+    assert pytest.approx(m_train.sum(), 5) == 500
+    assert pytest.approx(m_val.sum(), 5) == 200
+    assert pytest.approx(m_test.sum(), 5) == 300
 
 
 def test_split_by_num_for_UI_bigraph():
     e_list = [
-        [0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 1], [1, 2], [1, 3], [1, 4], [2, 2], [2, 3], [2, 4], [3, 3], [3, 4], [4, 4]
-        ]
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [0, 3],
+        [0, 4],
+        [1, 1],
+        [1, 2],
+        [1, 3],
+        [1, 4],
+        [2, 2],
+        [2, 3],
+        [2, 4],
+        [3, 3],
+        [3, 4],
+        [4, 4],
+    ]
     g = dhg.BiGraph(5, 5, e_list)
     train_num = 3
     train_adj, test_adj = split_by_num_for_UI_bigraph(g, train_num)
@@ -54,20 +68,15 @@ def test_split_by_num_for_UI_bigraph():
     assert len(test_adj[1]) == 2
 
 
-
 def test_split_by_ratio_for_UI_bigraph():
-    e_list = [
-        [0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 1], [1, 2], [1, 3], [1, 4], [2, 2], [2, 3], [2, 4], [3, 3], [3, 4], [4, 4]
-        ]
-    g = dhg.BiGraph(5, 5, e_list)
+    e_list = []
+    for idx in range(100):
+        e_list.append((0, idx))
+        e_list.append((1, idx))
+    g = dhg.BiGraph(2, 100, e_list)
     train_ratio = 0.6
     train_adj, test_adj = split_by_ratio_for_UI_bigraph(g, train_ratio)
-    assert len(train_adj) == 5
-    assert len(test_adj) == 3
-    assert len(train_adj[0]) == 4
-    assert len(train_adj[1]) == 3
-    assert len(train_adj[2]) == 2
-    assert len(train_adj[3]) == 2
-    assert len(test_adj[0]) == 3
-    assert len(test_adj[1]) == 2
-    assert len(test_adj[2]) == 2
+    assert (len(train_adj[0]) - 1) / len(g.nbr_v(0)) == pytest.approx(train_ratio, 0.1)
+    assert (len(train_adj[1]) - 1) / len(g.nbr_v(1)) == pytest.approx(train_ratio, 0.1)
+    assert (len(test_adj[0]) - 1) / len(g.nbr_v(0)) == pytest.approx(1 - train_ratio, 0.1)
+    assert (len(test_adj[1]) - 1) / len(g.nbr_v(1)) == pytest.approx(1 - train_ratio, 0.1)

tests/utils/test_structure.py

@@ -3,62 +3,67 @@
 
 
 def test_remap_edge_list():
-    e_list = [(1, 3), ('A', 100), (4.5, 'A')]
+    e_list = [(1, 3), (100, "A"), (4.5, "A")]
 
     e1, m = utils.remap_edge_list(e_list, ret_map=True)
     for i, (u, v) in enumerate(e_list):
-        assert e1[i][0] == m[u]
-        assert e1[i][1] == m[v]
+        assert e1[i][0] == m[str(u)]
+        assert e1[i][1] == m[str(v)]
 
-    e2, m = utils.remap_edge_list(e_list, ret_map=True, bipartite_graph=True)
+    e2, m_u, m_v = utils.remap_edge_list(e_list, ret_map=True, bipartite_graph=True)
     for i, (u, v) in enumerate(e_list):
-        assert e2[i][0] == m[u]
-        assert e2[i][1] == m[v]
+        assert e2[i][0] == m_u[str(u)]
+        assert e2[i][1] == m_v[str(v)]
 
 
 def test_remap_edge_lists():
-    e_list = [[(1, 3), ('A', 100), (4.5, 'A')], [(1, 5), ('B', 101), (4.1, 'A')]]
+    e_lists = [[(1, 3), (100, "A"), (4.5, "A")], [(1, 5), ("B", 101), (4.1, "A")]]
 
-    e1, m = utils.remap_edge_lists(e_list, ret_map=True)
-    for i, ee in enumerate(e_list):
-        for j, (u, v) in enumerate(ee):
-            assert e1[i][j][0] == m[u]
-            assert e1[i][j][1] == m[v]
+    e1, m = utils.remap_edge_lists(*e_lists, ret_map=True)
+    for i, e_list in enumerate(e_lists):
+        for j, (u, v) in enumerate(e_list):
+            assert e1[i][j][0] == m[str(u)]
+            assert e1[i][j][1] == m[str(v)]
 
-    e2, m = utils.remap_edge_list(e_list, ret_map=True, bipartite_graph=True)
-    for i, ee in enumerate(e_list):
-        for j, (u, v) in enumerate(ee):
-            assert e2[i][j][0] == m[u]
-            assert e2[i][j][1] == m[v]
+    e2, m_u, m_v = utils.remap_edge_lists(*e_lists, ret_map=True, bipartite_graph=True)
+    for i, e_list in enumerate(e_lists):
+        for j, (u, v) in enumerate(e_list):
+            assert e2[i][j][0] == m_u[str(u)]
+            assert e2[i][j][1] == m_v[str(v)]
 
 
 def test_remap_adj_list():
-    adj_list = [[0, 'A', 1.5], ['A', 1, 2], [1.5, 1, 0]]
+    adj_list = [[0, "A", 1.5], ["A", 1, 2], [1.5, 1, 0]]
     e1, m = utils.remap_adj_list(adj_list, ret_map=True)
     for i, adj in enumerate(adj_list):
         for j, a in enumerate(adj):
-            assert e1[i][j] == m[a]
+            assert e1[i][j] == m[str(a)]
 
-    e2, m = utils.remap_adj_list(adj_list, ret_map=True, bipartite_graph=True)
+    e2, m_u, m_v = utils.remap_adj_list(adj_list, ret_map=True, bipartite_graph=True)
     for i, adj in enumerate(adj_list):
         for j, a in enumerate(adj):
-            assert e2[i][j] == m[a]
+            if j == 0:
+                assert e2[i][j] == m_u[str(a)]
+            else:
+                assert e2[i][j] == m_v[str(a)]
 
 
 def test_remap_adj_lists():
-    adj_lists = [[[0, 'A', 1.5], ['A', 1, 2], [1.5, 1, 0]], [[0, 3, 'A', 'B'], [1, 2, 'A', 'B'], ['A', 'B', 0, 1]]]
-    e1, m = utils.remap_adj_lists(adj_lists, ret_map=True)
+    adj_lists = [[[0, "A", 1.5], ["A", 1, 2], [1.5, 1, 0]], [[0, 3, "A", "B"], [1, 2, "A", "B"], ["A", "B", 0, 1]]]
+    e1, m = utils.remap_adj_lists(*adj_lists, ret_map=True)
     for i, adj_list in enumerate(adj_lists):
         for j, adj in enumerate(adj_list):
             for k, a in enumerate(adj):
-                assert e1[i][j][k] == m[a]
+                assert e1[i][j][k] == m[str(a)]
 
-    e2, m = utils.remap_adj_list(adj_lists, ret_map=True, bipartite_graph=True)
+    e2, m_u, m_v = utils.remap_adj_lists(*adj_lists, ret_map=True, bipartite_graph=True)
     for i, adj_list in enumerate(adj_lists):
         for j, adj in enumerate(adj_list):
             for k, a in enumerate(adj):
-                assert e2[i][j][k] == m[a]
-
+                if k == 0:
+                    assert e2[i][j][k] == m_u[str(a)]
+                else:
+                    assert e2[i][j][k] == m_v[str(a)]
 
 
 def test_edge_list_to_adj_list():
@@ -95,4 +100,4 @@ def test_adj_list_to_edge_list():
     assert (1, 3) in e_list
     assert (1, 4) in e_list
     assert (2, 3) in e_list
-    assert len(e_list) == 7   # 8 ???
+    assert len(e_list) == 8  # 8 ???