chore: import upstream snapshot with attribution

2026-07-13 12:36:30 +08:00
commit 55ab4e4a73
473 changed files with 72932 additions and 0 deletions
@@ -0,0 +1,4 @@
+-1.765814423561096191e-01 2.083084881305694580e-01 -1.271556913852691650e-01 -1.702362895011901855e-01 8.119292855262756348e-01 -3.134809732437133789e-01 -9.992567449808120728e-02 -1.093881502747535706e-01
+-2.064122706651687622e-01 -1.475724577903747559e-01 -1.439859867095947266e-01 -7.331190109252929688e-01 6.787545084953308105e-01 -3.651908636093139648e-01 -9.232180565595626831e-02 -8.407155275344848633e-01
+-1.765814423561096191e-01 2.083084881305694580e-01 -1.271556913852691650e-01 -1.702362895011901855e-01 8.119292855262756348e-01 -3.134809732437133789e-01 -9.992567449808120728e-02 -1.093881502747535706e-01
+-2.064122706651687622e-01 -1.475724577903747559e-01 -1.439859867095947266e-01 -7.331190109252929688e-01 6.787545084953308105e-01 -3.651908636093139648e-01 -9.232180565595626831e-02 -8.407155275344848633e-01
@@ -0,0 +1,101 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+
+
+class Test_Deepwalk(unittest.TestCase):
+    def setUp(self):
+        self.ds = eg.datasets.get_graph_karateclub()
+        self.edges = [(1, 4), (2, 4)]
+        self.test_graphs = []
+        self.test_graphs.append(eg.classes.DiGraph(self.edges))
+        self.shs = eg.common_greedy(self.ds, int(len(self.ds.nodes) / 3))
+
+        self.graph = eg.Graph()
+        self.graph.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
+
+        self.empty_graph = eg.Graph()
+
+        self.single_node_graph = eg.Graph()
+        self.single_node_graph.add_node(0)
+
+    def test_deepwalk(self):
+        for i in self.test_graphs:
+            print(eg.deepwalk(i))
+
+    def test_deepwalk_output_structure(self):
+        emb, sim = eg.deepwalk(
+            self.graph,
+            dimensions=16,
+            walk_length=5,
+            num_walks=3,
+            window=2,
+            min_count=1,
+            batch_words=4,
+            epochs=5,
+        )
+        self.assertIsInstance(emb, dict)
+        self.assertIsInstance(sim, dict)
+        for k, v in emb.items():
+            self.assertEqual(len(v), 16)
+            self.assertTrue(isinstance(v, np.ndarray))
+
+    def test_deepwalk_similarity_keys_match_nodes(self):
+        emb, sim = eg.deepwalk(
+            self.graph,
+            dimensions=8,
+            walk_length=3,
+            num_walks=2,
+            window=2,
+            min_count=1,
+            batch_words=2,
+            epochs=3,
+        )
+        self.assertEqual(set(emb.keys()), set(sim.keys()))
+        self.assertEqual(set(emb.keys()), set(self.graph.nodes))
+
+    def test_deepwalk_on_single_node(self):
+        emb, sim = eg.deepwalk(
+            self.single_node_graph,
+            dimensions=4,
+            walk_length=2,
+            num_walks=1,
+            window=1,
+            min_count=1,
+            batch_words=2,
+            epochs=2,
+        )
+        self.assertEqual(len(emb), 1)
+        self.assertEqual(list(emb.keys()), [0])
+        self.assertEqual(len(emb[0]), 4)
+
+    def test_deepwalk_on_empty_graph(self):
+        with self.assertRaises(RuntimeError):
+            eg.deepwalk(
+                self.empty_graph,
+                dimensions=4,
+                walk_length=2,
+                num_walks=1,
+                window=1,
+                min_count=1,
+                batch_words=2,
+                epochs=2,
+            )
+
+    def test_deepwalk_walk_length_zero(self):
+        emb, sim = eg.deepwalk(
+            self.graph,
+            dimensions=4,
+            walk_length=0,
+            num_walks=2,
+            window=1,
+            min_count=1,
+            batch_words=2,
+            epochs=2,
+        )
+        self.assertEqual(len(emb), len(self.graph.nodes))
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,77 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+
+
+class Test_LINE(unittest.TestCase):
+    def setUp(self):
+        self.edges = [(0, 1), (1, 2), (2, 3), (3, 4)]
+        self.graph = eg.Graph()
+        self.graph.add_edges_from(self.edges)
+
+    def test_output_is_dict_with_correct_dim(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=16, walk_length=10, walk_num=5, order=1
+        )
+        emb = model(self.graph, return_dict=True)
+        self.assertIsInstance(emb, dict)
+        for v in emb.values():
+            self.assertEqual(len(v), 16)
+
+    def test_output_as_matrix(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=8, walk_length=5, walk_num=3, order=1
+        )
+        emb = model(self.graph, return_dict=False)
+        self.assertEqual(emb.shape, (len(self.graph.nodes), 8))
+
+    def test_output_with_order_2(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=16, walk_length=10, walk_num=5, order=2
+        )
+        emb = model(self.graph)
+        for vec in emb.values():
+            self.assertEqual(len(vec), 16)
+
+    def test_output_with_order_3_combination(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=16, walk_length=10, walk_num=5, order=3
+        )
+        emb = model(self.graph)
+        for vec in emb.values():
+            self.assertEqual(len(vec), 16)
+
+    def test_directed_graph(self):
+        g = eg.DiGraph()
+        g.add_edges_from(self.edges)
+        model = eg.functions.graph_embedding.LINE(
+            dimension=8, walk_length=5, walk_num=3, order=1
+        )
+        emb = model(g)
+        self.assertEqual(len(emb), len(g.nodes))
+
+    def test_empty_graph_raises(self):
+        g = eg.Graph()
+        model = eg.functions.graph_embedding.LINE(
+            dimension=8, walk_length=5, walk_num=3, order=1
+        )
+        with self.assertRaises(Exception):
+            _ = model(g)
+
+    def test_embeddings_are_normalized(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=16, walk_length=10, walk_num=5, order=1
+        )
+        emb = model(self.graph)
+        for vec in emb.values():
+            norm = np.linalg.norm(vec)
+            self.assertTrue(np.isclose(norm, 1.0, atol=1e-5))
+
+    def test_embedding_value_finiteness(self):
+        model = eg.functions.graph_embedding.LINE(
+            dimension=16, walk_length=10, walk_num=5, order=1
+        )
+        emb = model(self.graph)
+        for vec in emb.values():
+            self.assertTrue(np.all(np.isfinite(vec)))
@@ -0,0 +1,57 @@
+import unittest
+
+import easygraph as eg
+import easygraph.functions.graph_embedding as fn
+import numpy as np
+
+
+class Test_Nobe(unittest.TestCase):
+    def setUp(self):
+        self.ds = eg.datasets.get_graph_karateclub()
+        self.edges = [(1, 4), (2, 4), (4, 1), (0, 4), (4, 3)]
+        self.test_directed_graphs = [eg.DiGraph()]
+        self.test_undirected_graphs = [eg.Graph(self.edges)]
+        self.test_directed_graphs.append(eg.classes.DiGraph(self.edges))
+        self.shs = eg.common_greedy(self.ds, int(len(self.ds.nodes) / 3))
+
+        self.valid_graph = eg.Graph([(0, 1), (1, 2), (2, 0), (2, 3), (3, 4)])
+        self.directed_graph = eg.DiGraph([(0, 1), (1, 2)])
+        self.graph_with_isolated = eg.Graph()
+        self.graph_with_isolated.add_edges_from([(0, 1), (1, 2)])
+        self.graph_with_isolated.add_node(3)
+        self.graph_with_isolated.add_node(4)
+
+    def test_NOBE(self):
+        fn.NOBE(self.test_undirected_graphs[0], 1)
+
+    def test_NOBE_GA(self):
+        """
+        for i in self.test_graphs:
+            eg.functions.NOBE_GA(i, K=1)
+            print(i)
+        """
+        fn.NOBE_GA(self.test_directed_graphs[1], 1)
+
+    def test_nobe_output_shape(self):
+        emb = fn.NOBE(self.valid_graph, K=2)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape[1], 2)
+
+    def test_nobe_ga_output_shape(self):
+        undirected_graph = eg.Graph([(0, 1), (1, 2), (2, 3)])
+        emb = fn.NOBE_GA(undirected_graph, K=2)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape[1], 2)
+
+    def test_nobe_on_graph_with_isolated_nodes(self):
+        emb = fn.NOBE(self.graph_with_isolated, K=2)
+        self.assertEqual(emb.shape[0], len(self.graph_with_isolated))
+
+    def test_nobe_invalid_K_zero(self):
+        emb = fn.NOBE(self.valid_graph, 0)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape, (len(self.valid_graph), 0))
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+
+from easygraph.functions.graph_embedding.NOBE import NOBE
+from easygraph.functions.graph_embedding.NOBE import NOBE_GA
+
+
+class Test_Nobe(unittest.TestCase):
+    def setUp(self):
+        self.ds = eg.datasets.get_graph_karateclub()
+        self.edges = [(1, 4), (2, 4), (4, 1), (0, 4)]
+        self.test_graphs = [eg.classes.DiGraph(self.edges)]
+        self.test_undirected_graphs = [eg.classes.Graph(self.edges)]
+        self.shs = eg.common_greedy(self.ds, int(len(self.ds.nodes) / 3))
+
+        self.valid_graph = eg.Graph([(0, 1), (1, 2), (2, 3)])
+        self.directed_graph = eg.DiGraph([(0, 1), (1, 2)])
+        self.graph_with_isolated = eg.Graph([(0, 1), (1, 2)])
+        self.graph_with_isolated.add_node(5)  # isolated node
+
+    #
+    def test_NOBE(self):
+        for i in self.test_graphs:
+            NOBE(i, K=1)
+
+    def test_NOBE_GA(self):
+        for i in self.test_undirected_graphs:
+            NOBE_GA(i, K=1)
+
+    def test_nobe_embedding_shape(self):
+        emb = NOBE(self.valid_graph, K=2)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape, (len(self.valid_graph.nodes), 2))
+
+    def test_nobe_ga_embedding_shape(self):
+        emb = NOBE_GA(self.valid_graph, K=2)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape, (len(self.valid_graph.nodes), 2))
+
+    def test_nobe_invalid_k_zero(self):
+        emb = NOBE(self.valid_graph, 0)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape, (len(self.valid_graph), 0))
+
+    def test_nobe_ga_invalid_k_zero(self):
+        emb = NOBE_GA(self.valid_graph, 0)
+        self.assertIsInstance(emb, np.ndarray)
+        self.assertEqual(emb.shape, (len(self.valid_graph), 0))
+
+    def test_nobe_with_isolated_node(self):
+        emb = NOBE(self.graph_with_isolated, K=2)
+        self.assertEqual(emb.shape[0], len(self.graph_with_isolated))
+
+
+# if __name__ == "__main__":
+#     unittest.main()
@@ -0,0 +1,107 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+import torch
+
+
+class Test_Sdne(unittest.TestCase):
+    def setUp(self):
+        self.ds = eg.datasets.get_graph_karateclub()
+        self.edges = [
+            (1, 4),
+            (2, 4),
+            (4, 1),
+            (0, 4),
+            (4, 3),
+        ]
+        self.test_graphs = []
+        self.test_graphs.append(eg.classes.DiGraph(self.edges))
+        self.shs = eg.common_greedy(self.ds, int(len(self.ds.nodes) / 3))
+        self.graph = eg.DiGraph()
+        self.graph.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0)])
+        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    def test_sdne(self):
+        sdne = eg.SDNE(
+            graph=self.test_graphs[0],
+            node_size=len(self.test_graphs[0].nodes),
+            nhid0=128,
+            nhid1=64,
+            dropout=0.025,
+            alpha=2e-2,
+            beta=10,
+        )
+        # todo add test
+        # emb = sdne.train(sdne)
+
+    def test_sdne_model_instantiation(self):
+        model = eg.SDNE(
+            graph=self.graph,
+            node_size=len(self.graph.nodes),
+            nhid0=32,
+            nhid1=16,
+            dropout=0.05,
+            alpha=0.01,
+            beta=5.0,
+        )
+        self.assertIsInstance(model, eg.SDNE)
+
+    def test_sdne_training_embedding_output(self):
+        model = eg.SDNE(
+            graph=self.graph,
+            node_size=len(self.graph.nodes),
+            nhid0=16,
+            nhid1=8,
+            dropout=0.05,
+            alpha=0.01,
+            beta=5.0,
+        )
+        embedding = model.train(
+            model=model,
+            epochs=5,
+            lr=0.01,
+            bs=2,
+            step_size=2,
+            gamma=0.9,
+            nu1=1e-5,
+            nu2=1e-4,
+            device=self.device,
+            output="test.emb",
+        )
+        self.assertIsInstance(embedding, np.ndarray)
+        self.assertEqual(embedding.shape, (len(self.graph.nodes), 8))
+
+    def test_savector_output_shape(self):
+        adj, _ = eg.get_adj(self.graph)
+        model = eg.SDNE(
+            graph=self.graph,
+            node_size=len(self.graph.nodes),
+            nhid0=16,
+            nhid1=8,
+            dropout=0.05,
+            alpha=0.01,
+            beta=5.0,
+        )
+        with torch.no_grad():
+            emb = model.savector(adj)
+        self.assertEqual(emb.shape, (len(self.graph.nodes), 8))
+
+    def test_get_adj_shape_and_symmetry(self):
+        adj, node_count = eg.get_adj(self.graph)
+        self.assertEqual(adj.shape[0], node_count)
+        self.assertTrue(torch.equal(adj, adj.T))  # check symmetry for undirected
+
+    def test_training_on_empty_graph(self):
+        empty_graph = eg.Graph()
+        model = eg.SDNE(
+            graph=empty_graph,
+            node_size=0,
+            nhid0=8,
+            nhid1=4,
+            dropout=0.05,
+            alpha=0.01,
+            beta=5.0,
+        )
+        with self.assertRaises(ValueError):
+            model.train(model=model, epochs=5, device=self.device)