test

Author: zhangxwww

dhg/structure/hypergraphs/hypergraph.py

@@ -96,7 +96,7 @@ def draw(
         pull_center_strength: float = 1.0,
     ):
         r"""Draw the hypergraph structure.
-        
+
         Args:
             ``e_style`` (``str``): The style of hyperedges. The available styles are only ``'circle'``. Defaults to ``'circle'``.
             ``v_label`` (``list``): The labels of vertices. Defaults to ``None``.
@@ -201,7 +201,7 @@ def from_feature_kNN(features: torch.Tensor, k: int, device: torch.device = torc
 
     @staticmethod
     def from_graph(graph: "Graph", device: torch.device = torch.device("cpu")) -> "Hypergraph":
-        r"""Construct the hypergraph from the graph. Each edge in the graph is treated as a hyperedge in the constructed hypergraph. 
+        r"""Construct the hypergraph from the graph. Each edge in the graph is treated as a hyperedge in the constructed hypergraph.
 
         .. note::
             The construsted hypergraph is a 2-uniform hypergraph, and has the same number of vertices and edges/hyperedges as the graph.
@@ -263,13 +263,13 @@ def from_graph_kHop(
 
     @staticmethod
     def _e_list_from_bigraph(bigraph: "BiGraph", U_as_vertex: bool = True) -> List[tuple]:
-        r"""Construct hyperedges from the bipartite graph. 
+        r"""Construct hyperedges from the bipartite graph.
 
         Args:
             ``bigraph`` (``BiGraph``): The bipartite graph to construct the hypergraph.
-            ``U_as_vertex`` (``bool``, optional): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
-             will be treated as vertices and hyperedges in the constructed hypergraph, respectively. 
-             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
+            ``U_as_vertex`` (``bool``, optional): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
+             will be treated as vertices and hyperedges in the constructed hypergraph, respectively.
+             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
              will be treated as hyperedges and vertices in the constructed hypergraph, respectively. Defaults to ``True``.
         """
         e_list = []
@@ -289,13 +289,13 @@ def _e_list_from_bigraph(bigraph: "BiGraph", U_as_vertex: bool = True) -> List[t
     def from_bigraph(
         bigraph: "BiGraph", U_as_vertex: bool = True, device: torch.device = torch.device("cpu")
     ) -> "Hypergraph":
-        r"""Construct the hypergraph from the bipartite graph. 
+        r"""Construct the hypergraph from the bipartite graph.
 
         Args:
             ``bigraph`` (``BiGraph``): The bipartite graph to construct the hypergraph.
-            ``U_as_vertex`` (``bool``, optional): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
-             will be treated as vertices and hyperedges in the constructed hypergraph, respectively. 
-             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
+            ``U_as_vertex`` (``bool``, optional): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
+             will be treated as vertices and hyperedges in the constructed hypergraph, respectively.
+             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
              will be treated as hyperedges and vertices in the constructed hypergraph, respectively. Defaults to ``True``.
             ``device`` (``torch.device``, optional): The device to store the hypergraph. Defaults to ``torch.device('cpu')``.
         """
@@ -356,7 +356,7 @@ def add_hyperedges_from_feature_kNN(self, feature: torch.Tensor, k: int, group_n
         self.add_hyperedges(e_list, group_name=group_name)
 
     def add_hyperedges_from_graph(self, graph: "Graph", group_name: str = "main"):
-        r"""Add hyperedges from edges in the graph. Each edge in the graph is treated as a hyperedge. 
+        r"""Add hyperedges from edges in the graph. Each edge in the graph is treated as a hyperedge.
 
         Args:
             ``graph`` (``Graph``): The graph to join the hypergraph.
@@ -385,13 +385,13 @@ def add_hyperedges_from_graph_kHop(
         self.add_hyperedges(e_list, group_name=group_name)
 
     def add_hyperedges_from_bigraph(self, bigraph: "BiGraph", U_as_vertex: bool = False, group_name: str = "main"):
-        r"""Add hyperedges from the bipartite graph. 
+        r"""Add hyperedges from the bipartite graph.
 
         Args:
             ``bigraph`` (``BiGraph``): The bigraph to join the hypergraph.
-            ``U_as_vertex`` (``bool``): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
-             will be treated as vertices and hyperedges in the constructed hypergraph, respectively. 
-             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}` 
+            ``U_as_vertex`` (``bool``): If set to ``True``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
+             will be treated as vertices and hyperedges in the constructed hypergraph, respectively.
+             If set to ``False``, vertices in set :math:`\mathcal{U}` and set :math:`\mathcal{V}`
              will be treated as hyperedges and vertices in the constructed hypergraph, respectively. Defaults to ``True``.
             ``group_name`` (``str``, optional): The target hyperedge group to add these hyperedges. Defaults to the ``main`` hyperedge group.
         """
@@ -624,17 +624,17 @@ def group_names(self) -> List[str]:
     # properties for deep learning
     @property
     def vars_for_DL(self) -> List[str]:
-        r"""Return a name list of available variables for deep learning in the hypergraph including 
+        r"""Return a name list of available variables for deep learning in the hypergraph including
 
         Sparse Matrices:
-        
+
         .. math::
             \mathbf{H}, \mathbf{H}^\top, \mathcal{L}_{sym}, \mathcal{L}_{rw} \mathcal{L}_{HGNN},
-        
+
         Sparse Diagnal Matrices:
 
         .. math::
-            \mathbf{W}_e, \mathbf{D}_v, \mathbf{D}_v^{-1}, \mathbf{D}_v^{-\frac{1}{2}}, \mathbf{D}_e, \mathbf{D}_e^{-1}, 
+            \mathbf{W}_e, \mathbf{D}_v, \mathbf{D}_v^{-1}, \mathbf{D}_v^{-\frac{1}{2}}, \mathbf{D}_e, \mathbf{D}_e^{-1},
 
         Vectors:
 
@@ -670,7 +670,7 @@ def v2e_src(self) -> torch.Tensor:
 
     def v2e_src_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the source vertex index vector :math:`\overrightarrow{v2e}_{src}` of the connections (vertices point to hyperedges) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -685,7 +685,7 @@ def v2e_dst(self) -> torch.Tensor:
 
     def v2e_dst_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the destination hyperedge index vector :math:`\overrightarrow{v2e}_{dst}` of the connections (vertices point to hyperedges) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -700,7 +700,7 @@ def v2e_weight(self) -> torch.Tensor:
 
     def v2e_weight_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the weight vector :math:`\overrightarrow{v2e}_{weight}` of the connections (vertices point to hyperedges) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -715,7 +715,7 @@ def e2v_src(self) -> torch.Tensor:
 
     def e2v_src_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the source hyperedge index vector :math:`\overrightarrow{e2v}_{src}` of the connections (hyperedges point to vertices) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -730,7 +730,7 @@ def e2v_dst(self) -> torch.Tensor:
 
     def e2v_dst_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the destination vertex index vector :math:`\overrightarrow{e2v}_{dst}` of the connections (hyperedges point to vertices) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -745,7 +745,7 @@ def e2v_weight(self) -> torch.Tensor:
 
     def e2v_weight_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the weight vector :math:`\overrightarrow{e2v}_{weight}` of the connections (hyperedges point to vertices) in the specified hyperedge group.
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -1010,7 +1010,7 @@ def N_e_of_group(self, v_idx: int, group_name: str) -> torch.Tensor:
         return e_indices.clone()
 
     def N_v(self, e_idx: int) -> torch.Tensor:
-        r"""Return the neighbor vertices of the specified hyperedge with ``torch.Tensor`` format. 
+        r"""Return the neighbor vertices of the specified hyperedge with ``torch.Tensor`` format.
 
         .. note::
             The ``e_idx`` must be in the range of [0, :attr:`num_e`).
@@ -1048,7 +1048,7 @@ def smoothing(self, X: torch.Tensor, L: torch.Tensor, lamb: float) -> torch.Tens
     @property
     def L_sym(self) -> torch.Tensor:
         r"""Return the symmetric Laplacian matrix :math:`\mathcal{L}_{sym}` of the hypergraph with ``torch.sparse_coo_tensor`` format.
-        
+
         .. math::
             \mathcal{L}_{sym} = \mathbf{I} - \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}}
         """
@@ -1064,10 +1064,10 @@ def L_sym(self) -> torch.Tensor:
 
     def L_sym_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the symmetric Laplacian matrix :math:`\mathcal{L}_{sym}` of the specified hyperedge group with ``torch.sparse_coo_tensor`` format.
-        
+
         .. math::
             \mathcal{L}_{sym} = \mathbf{I} - \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}}
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -1085,7 +1085,7 @@ def L_sym_of_group(self, group_name: str) -> torch.Tensor:
     @property
     def L_rw(self) -> torch.Tensor:
         r"""Return the random walk Laplacian matrix :math:`\mathcal{L}_{rw}` of the hypergraph with ``torch.sparse_coo_tensor`` format.
-        
+
         .. math::
             \mathcal{L}_{rw} = \mathbf{I} - \mathbf{D}_v^{-1} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top
         """
@@ -1105,10 +1105,10 @@ def L_rw(self) -> torch.Tensor:
 
     def L_rw_of_group(self, group_name: str) -> torch.Tensor:
         r"""Return the random walk Laplacian matrix :math:`\mathcal{L}_{rw}` of the specified hyperedge group with ``torch.sparse_coo_tensor`` format.
-        
+
         .. math::
             \mathcal{L}_{rw} = \mathbf{I} - \mathbf{D}_v^{-1} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -1151,7 +1151,7 @@ def L_HGNN_of_group(self, group_name: str) -> torch.Tensor:
 
         .. math::
             \mathcal{L}_{HGNN} = \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}}
-        
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
         """
@@ -1172,8 +1172,8 @@ def smoothing_with_HGNN(self, X: torch.Tensor, drop_rate: float = 0.0) -> torch.
         r"""Return the smoothed feature matrix with the HGNN Laplacian matrix :math:`\mathcal{L}_{HGNN}`.
 
             .. math::
-                \mathbf{X} = \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}} \mathbf{X} 
-            
+                \mathbf{X} = \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}} \mathbf{X}
+
         Args:
             ``X`` (``torch.Tensor``): The feature matrix. Size :math:`(|\mathcal{V}|, C)`.
             ``drop_rate`` (``float``): Dropout rate. Randomly dropout the connections in incidence matrix with probability ``drop_rate``. Default: ``0.0``.
@@ -1190,8 +1190,8 @@ def smoothing_with_HGNN_of_group(self, group_name: str, X: torch.Tensor, drop_ra
         r"""Return the smoothed feature matrix with the HGNN Laplacian matrix :math:`\mathcal{L}_{HGNN}`.
 
             .. math::
-                \mathbf{X} = \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}} \mathbf{X} 
-            
+                \mathbf{X} = \mathbf{D}_v^{-\frac{1}{2}} \mathbf{H} \mathbf{W}_e \mathbf{D}_e^{-1} \mathbf{H}^\top \mathbf{D}_v^{-\frac{1}{2}} \mathbf{X}
+
         Args:
             ``group_name`` (``str``): The name of the specified hyperedge group.
             ``X`` (``torch.Tensor``): The feature matrix. Size :math:`(|\mathcal{V}|, C)`.

tests/datapipe/test_loaders.py

@@ -3,6 +3,16 @@
 from dhg.datapipe import load_from_txt
 
 
-def test_load_from_txt():
-    # TODO
-    pass
+def test_load_from_txt(tmp_path):
+    origin = [
+        [0, 1, 2],
+        [3, 4],
+        [5, 6, 7, 8]
+    ]
+    with open(tmp_path, 'w') as f:
+        for ori in origin:
+            f.write(' '.join(map(str, ori)) + '\n')
+    data = load_from_txt(tmp_path)
+    for ori, dat in zip(origin, data):
+        for a, b in zip(ori, dat):
+            assert a == b

tests/metrics/test_classification.py

@@ -1,19 +1,25 @@
 import pytest
 
 import torch
+from sklearn.metrics import f1_score, confusion_matrix
 import dhg.metrics.classification as dm
 
 
 def test_accuracy():
-    # TODO
-    pass
+    y_true = torch.tensor([0, 1, 2, 0, 1, 3])
+    y_pred = torch.tensor([0, 2, 1, 0, 2, 3])
+    assert dm.accuracy(y_true, y_pred) == 0.5
 
 
 def test_f1_score():
-    # TODO
-    pass
+    y_true = torch.tensor([0, 1, 2, 0, 1, 3])
+    y_pred = torch.tensor([0, 2, 1, 0, 2, 3])
+    assert dm.f1_score(y_true, y_pred, 'macro') == f1_score(y_true, y_pred, average='macro')
+    assert dm.f1_score(y_true, y_pred, 'micro') == f1_score(y_true, y_pred, average='micro')
+    assert dm.f1_score(y_true, y_pred, 'weighted') == f1_score(y_true, y_pred, average='weighted')
 
 
 def test_confusion_matrix():
-    # TODO
-    pass
+    y_true = torch.tensor([0, 1, 2, 0, 1, 3])
+    y_pred = torch.tensor([0, 2, 1, 0, 2, 3])
+    assert np.all(dm.confusion_matrix(y_true, y_pred) == confusion_matrix(y_true, y_pred))

tests/metrics/test_recommender.py

@@ -1,6 +1,7 @@
 import pytest
 
 import torch
+from sklearn.metrics import ndcg_score
 import dhg.metrics.recommender as dm
 
 
@@ -23,5 +24,9 @@ def test_precision():
 
 
 def test_ndcg():
-    # TODO
-    pass
+    y_true = torch.tensor([[0, 1, 2, 3, 4], [2, 0, 1, 4, 3]])
+    y_score = torch.tensor([[0.8, 0.9, 0.6, 0.7, 0.4], [0.4, 0.5, 0.6, 0.7, 0.8]])
+    assert dm.ndcg(y_true, y_score, k=2) == pytest.approx(ndcg_score(y_true, y_score, k=2))
+    assert dm.ndcg(y_true, y_score, k=3) == pytest.approx(ndcg_score(y_true, y_score, k=3))
+    assert dm.ndcg(y_true, y_score, k=4) == pytest.approx(ndcg_score(y_true, y_score, k=4))
+    assert dm.ndcg(y_true, y_score, k=5) == pytest.approx(ndcg_score(y_true, y_score, k=5))

tests/metrics/test_retrieval.py

@@ -1,13 +1,11 @@
 import pytest
 
+import numpy as np
+from sklearn.metrics import average_precision_score, ndcg_score
 import torch
 import dhg.metrics.retrieval as dm
 
 
-def test_precision():
-    pass
-
-
 def test_recall():
     y_true = torch.tensor([0, 1, 0, 0, 1, 1])
     y_pred = torch.tensor([0.8, 0.9, 0.6, 0.7, 0.4, 0.5])
@@ -57,12 +55,30 @@ def test_ap():
 
 
 def test_map():
-    # TODO
-    pass
+    y_true = torch.tensor([
+        [True, False, True, False, True],
+        [False, False, False, True, True],
+        [True, True, False, True, False],
+        [False, True, True, False, True],
+    ])
+    y_pred = torch.tensor([
+        [0.2, 0.8, 0.5, 0.4, 0.3],
+        [0.8, 0.2, 0.3, 0.9, 0.4],
+        [0.2, 0.4, 0.5, 0.9, 0.8],
+        [0.8, 0.2, 0.9, 0.3, 0.7],
+    ])
+    ap = []
+    for i in range(y_true.shape[0]):
+        ap.append(average_precision_score(y_true[i], y_pred[i]))
+    map = np.mean(ap)
+    assert dm.map(y_true, y_pred, method='legacy') == pytest.approx(map)
+
 
 
 def test_ndcg():
-    # TODO
+    y_true = torch.tensor([0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1])
+    y_pred = torch.tensor([0.23, 0.76, 0.01, 0.91, 0.13, 0.45, 0.12, 0.03, 0.38, 0.11, 0.03, 0.09, 0.65, 0.07, 0.12, 0.24, 0.10, 0.23, 0.46, 0.08])
+    assert dm.ndcg(y_true, y_pred, k=5) == pytest.approx(ndcg_score(y_true.reshape(1, -1), y_pred.reshape(1, -1), k=5))
     pass