def test_diteration(self):
# test convergence by tolerance
for adjacency in [house(), test_graph(), test_digraph()]:
seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
pr = get_pagerank(adjacency,
damping_factor=0.85,
n_iter=100,
tol=10,
solver='diteration',
seeds=seeds)
self.assertTrue(is_proba_array(pr))
# test graph with some null out-degree
adjacency = edgelist2adjacency([(0, 1)])
seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
pr = get_pagerank(adjacency,
damping_factor=0.85,
n_iter=100,
tol=10,
solver='diteration',
seeds=seeds)
self.assertTrue(is_proba_array(pr))
# test invalid entry
adjacency = Regularizer(house(), 0.1)
seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
with self.assertRaises(ValueError):
get_pagerank(adjacency,
damping_factor=0.85,
n_iter=100,
tol=10,
solver='diteration',
seeds=seeds)
def test_signature(self):
adjacency = house()
with self.assertRaises(ValueError):
is_edge(adjacency, 'toto')
with self.assertRaises(ValueError):
is_edge(adjacency, np.ones(8).reshape((2, 2, 2)))
def test_addition(self):
addition = self.undirected + self.undirected
expected = SparseLR(2 * house(), [(np.ones(5), 2 * np.ones(5))])
err = (addition.sparse_mat - expected.sparse_mat).count_nonzero()
self.assertEqual(err, 0)
x = np.random.rand(5)
self.assertAlmostEqual(
np.linalg.norm(addition.dot(x) - expected.dot(x)), 0)
def test_isomorphism(self):
ref = house()
n = ref.shape[0]
adjacency = house()
reorder = list(range(n))
np.random.shuffle(reorder)
adjacency = adjacency[reorder][:, reorder]
self.assertTrue(are_isomorphic(ref, adjacency))
adjacency = bow_tie()
self.assertFalse(are_isomorphic(ref, adjacency))
adjacency = linear_graph(n)
self.assertFalse(are_isomorphic(ref, adjacency))
adjacency = linear_graph(n + 1)
self.assertFalse(are_isomorphic(ref, adjacency))
def test_aggregate(self):
adjacency = house()
biadjacency = star_wars()
louvain = Louvain(return_aggregate=True)
louvain.fit(adjacency)
self.assertTrue(np.issubdtype(louvain.adjacency_.dtype, np.float_))
bilouvain = BiLouvain(return_aggregate=True)
bilouvain.fit(biadjacency)
self.assertTrue(np.issubdtype(bilouvain.biadjacency_.dtype, np.float_))
def test_piteration(self):
# test on SparseLR matrix
adjacency = Regularizer(house(), 0.1)
seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
pr = get_pagerank(adjacency,
damping_factor=0.85,
n_iter=100,
tol=10,
solver='piteration',
seeds=seeds)
self.assertTrue(is_proba_array(pr))
def test_iso(self):
adjacency = house()
n = adjacency.indptr.shape[0] - 1
reorder = list(range(n))
np.random.shuffle(reorder)
adjacency2 = adjacency[reorder][:, reorder]
l1 = WeisfeilerLehman().fit_transform(adjacency)
l2 = WeisfeilerLehman().fit_transform(adjacency2)
l1.sort()
l2.sort()
self.assertTrue((l1 == l2).all())
def test_query(self):
adjacency = house()
algo = Dummy().fit(adjacency)
query = 'toto'
with self.assertRaises(ValueError):
algo.predict(query)
query = np.ones((2, 3))
with self.assertRaises(ValueError):
algo.predict(query)
query = [(0, 1), (2, 3)]
pred = algo.predict(query)
self.assertEqual(pred.shape, (len(query),))
def test_options(self):
adjacency = house()
dag = DAG()
dag.fit(adjacency)
self.assertEqual(dag.indptr_.shape[0], adjacency.shape[0] + 1)
self.assertEqual(dag.indices_.shape[0], 6)
with self.assertRaises(ValueError):
dag.fit(adjacency, sorted_nodes=np.arange(3))
with self.assertRaises(ValueError):
dag = DAG(ordering='toto')
dag.fit(adjacency)
def test_dir2undir(self):
self.adjacency = rock_paper_scissors()
undirected_graph = directed2undirected(self.adjacency)
self.assertEqual(undirected_graph.shape, self.adjacency.shape)
self.assertTrue(is_symmetric(undirected_graph))
self.house = house()
error = 0.5 * directed2undirected(self.house) - self.house
self.assertEqual(error.nnz, 0)
n, m = self.adjacency.shape
slr = SparseLR(self.adjacency, [(np.ones(n), np.ones(m))])
undirected_graph = directed2undirected(slr)
self.assertTrue(type(undirected_graph) == SparseLR)
def test_undirected(self):
house_graph = house()
if is_numba_available:
self.paris_numba.fit(house_graph)
self.assertEqual(self.paris_numba.dendrogram_.shape[0], 4)
labels = straight_cut(self.paris_numba.dendrogram_,
sorted_clusters=True)
self.assertTrue(np.array_equal(labels, np.array([0, 0, 1, 1, 0])))
self.paris.fit(house_graph)
self.assertEqual(self.paris.dendrogram_.shape[0], 4)
labels = straight_cut(self.paris.dendrogram_, sorted_clusters=True)
self.assertTrue(np.array_equal(labels, np.array([0, 0, 1, 1, 0])))
karate_club_graph = karate_club()
self.paris.fit(karate_club_graph)
self.assertEqual(self.paris.dendrogram_.shape[0], 33)
labels = straight_cut(self.paris.dendrogram_)
self.assertEqual(np.max(labels), 1)
def test_dir2undir(self):
n = 3
adjacency = cyclic_digraph(n)
ref = directed2undirected(adjacency)
self.assertEqual(ref.shape, adjacency.shape)
self.assertTrue(is_symmetric(ref))
adjacency = house()
n = adjacency.shape[0]
error = 0.5 * directed2undirected(adjacency) - adjacency
self.assertEqual(error.nnz, 0)
slr = SparseLR(adjacency, [(np.zeros(n), np.zeros(n))])
slr = 0.5 * directed2undirected(slr)
self.assertEqual(slr.shape, (n, n))
x = np.random.randn(n)
error = np.linalg.norm(slr.dot(x) - adjacency.dot(x))
self.assertAlmostEqual(error, 0)
def test_early_stop(self):
adjacency = house()
wl = WeisfeilerLehman(max_iter=1)
labels = wl.fit_transform(adjacency)
self.assertTrue((labels == np.array([0, 1, 0, 0, 1])).all())
def test_init(self):
with self.assertRaises(ValueError):
SparseLR(house(), [(np.ones(5), np.ones(4))])
with self.assertRaises(ValueError):
SparseLR(house(), [(np.ones(4), np.ones(5))])
def setUp(self):
"""Simple regularized adjacency and biadjacency for tests."""
self.undirected = SparseLR(house(), [(np.ones(5), np.ones(5))])
self.bipartite = SparseLR(star_wars(), [(np.ones(4), np.ones(3))])
from sknetwork.ranking import PageRank from sknetwork.data import load_edge_list, house adjacency = house() pagerank = PageRank(solver='push') scores = pagerank.fit_transform(adjacency) print(scores) """ the result should be like: [0.17301832 0.22442742 0.1823948 0.18926552 0.23089394] """
def setUp(self):
self.adjacency: sparse.csr_matrix = karate_club()
self.house = house()
def setUp(self):
self.undirected = SparseLR(house(), [(np.ones(5), np.ones(5))])
self.bipartite = SparseLR(star_wars_villains(),
[(np.ones(4), np.ones(3))])
def test_house(self):
adjacency = house()
labels = WeisfeilerLehman().fit_transform(adjacency)
self.assertTrue((labels == np.array([0, 2, 1, 1, 2])).all())
