def test_louvain_hierarchy(self):
louvain = LouvainNE()
for adjacency in [
test_graph(),
test_graph_disconnect(),
test_digraph()
]:
self.assertTupleEqual(
louvain.fit_transform(adjacency).shape, (10, 2))
louvain.fit(test_bigraph())
self.assertTupleEqual(louvain.embedding_.shape, (6, 2))
louvain.fit(test_graph(), force_bipartite=True)
self.assertTupleEqual(louvain.embedding_.shape, (10, 2))
def test_options(self):
louvain = LouvainHierarchy(resolution=2)
adjacency = test_graph()
dendrogram = louvain.fit_transform(adjacency)
n = adjacency.shape[0]
self.assertEqual(dendrogram.shape, (n - 1, 4))
louvain = LouvainHierarchy(depth=1)
adjacency = test_graph()
dendrogram = louvain.fit_transform(adjacency)
n = adjacency.shape[0]
self.assertEqual(dendrogram.shape, (n - 1, 4))
self.assertEqual(dendrogram[:, 2].max(), 1)
def test_cosine(self):
biadjacency = test_bigraph()
method = GSVD(3, solver='lanczos')
embedding = method.fit_transform(biadjacency)
embedding_col = method.embedding_col_
fit, div, modularity = cosine_modularity(biadjacency,
embedding,
embedding_col,
return_all=True)
modularity = cosine_modularity(biadjacency,
embedding,
embedding_col,
return_all=False)
self.assertAlmostEqual(modularity, fit - div)
adjacency = test_graph()
embedding = method.fit_transform(adjacency)
fit, div, modularity = cosine_modularity(adjacency,
embedding,
return_all=True)
self.assertAlmostEqual(modularity, fit - div)
with self.assertRaises(ValueError):
cosine_modularity(biadjacency, embedding)
louvain = LouvainEmbedding()
embedding = louvain.fit_transform(adjacency)
fit, div, modularity = cosine_modularity(adjacency,
embedding,
return_all=True)
self.assertAlmostEqual(modularity, fit - div)
def setUp(self):
"""Basic graph for tests"""
self.adjacency = test_graph()
n = self.adjacency.shape[0]
labels = np.zeros(n)
labels[0] = 1
self.labels = labels.astype(int)
self.unique_cluster = np.zeros(n, dtype=int)
def test_basic(self):
methods = [PageRank(), Diffusion(), Closeness(), HITS(), Harmonic()]
for adjacency in [test_graph(), test_digraph()]:
n = adjacency.shape[0]
for method in methods:
score = method.fit_transform(adjacency)
self.assertEqual(score.shape, (n, ))
self.assertTrue(score.min() >= 0)
def test_operations(self):
adjacency = test_graph()
n = adjacency.shape[0]
polynome = Polynome(adjacency, np.arange(3))
x = np.random.randn(n)
y1 = (polynome * 2).dot(x)
y2 = (-polynome).dot(x)
self.assertAlmostEqual(np.linalg.norm(0.5 * y1 + y2), 0)
def test_random_projection(self):
for algo in [RandomProjection(), RandomProjection(random_walk=True)]:
adjacency = test_graph()
embedding = algo.fit_transform(adjacency)
self.assertEqual(embedding.shape[1], 2)
adjacency = test_digraph()
embedding = algo.fit_transform(adjacency)
self.assertEqual(embedding.shape[1], 2)
adjacency = test_graph_disconnect()
embedding = algo.fit_transform(adjacency)
self.assertEqual(embedding.shape[1], 2)
def test_predict(self):
louvain = LouvainEmbedding()
louvain.fit(test_graph())
embedding_vector = louvain.predict(
np.array([1, 0, 0, 0, 1, 1, 0, 0, 0, 1]))
self.assertEqual(embedding_vector.shape[0], 1)
bilouvain = BiLouvainEmbedding()
bilouvain.fit(test_bigraph())
embedding_vector = bilouvain.predict(np.array([1, 0, 0, 0, 1, 1]))
self.assertEqual(embedding_vector.shape[0], 1)
def test_options(self):
ward = Ward()
ward_options = Ward(embedding_method=Spectral(3), co_cluster=True)
for algo in [ward, ward_options]:
for input_matrix in [test_graph(), test_digraph(), test_bigraph()]:
dendrogram = algo.fit_transform(input_matrix)
self.assertEqual(dendrogram.shape,
(input_matrix.shape[0] - 1, 4))
if algo.co_cluster:
self.assertEqual(algo.dendrogram_full_.shape,
(sum(input_matrix.shape) - 1, 4))
def test_predict(self):
louvain = LouvainEmbedding()
louvain.fit(test_graph())
self.assertEqual(louvain.embedding_.shape[0], 10)
louvain.fit(test_graph(), force_bipartite=True)
self.assertEqual(louvain.embedding_.shape[0], 10)
for method in ['remove', 'merge', 'keep']:
louvain = LouvainEmbedding(isolated_nodes=method)
louvain.fit(test_graph())
embedding_vector = louvain.predict(
np.array([1, 0, 0, 0, 1, 1, 0, 0, 0, 1]))
self.assertEqual(embedding_vector.shape[0], 1)
for method in ['remove', 'merge', 'keep']:
bilouvain = LouvainEmbedding(isolated_nodes=method)
bilouvain.fit(test_bigraph())
embedding_vector = bilouvain.predict(
np.array([1, 0, 0, 0, 1, 1, 0, 1]))
self.assertEqual(embedding_vector.shape[0], 1)
def test_decomposition(self):
adjacency = test_graph()
n = adjacency.shape[0]
polynome = Polynome(adjacency, np.arange(3))
eigenvalues, eigenvectors = randomized_eig(polynome,
n_components=2,
which='LM')
self.assertEqual(eigenvalues.shape, (2, ))
self.assertEqual(eigenvectors.shape, (n, 2))
left_sv, sv, right_sv = randomized_svd(polynome, n_components=2)
self.assertEqual(left_sv.shape, (n, 2))
self.assertEqual(sv.shape, (2, ))
self.assertEqual(right_sv.shape, (2, n))
def test_options(self):
for adjacency in [test_graph(), test_digraph()]:
n = adjacency.shape[0]
force_atlas = ForceAtlas()
layout = force_atlas.fit_transform(adjacency)
self.assertEqual((n, 2), layout.shape)
force_atlas = ForceAtlas(lin_log=True)
layout = force_atlas.fit_transform(adjacency)
self.assertEqual((n, 2), layout.shape)
force_atlas = ForceAtlas(approx_radius=1.)
layout = force_atlas.fit_transform(adjacency)
self.assertEqual((n, 2), layout.shape)
force_atlas.fit(adjacency, pos_init=layout, n_iter=1)
def test_basic(self):
adjacency = test_graph()
betweenness = Betweenness()
scores = betweenness.fit_transform(adjacency)
self.assertEqual(len(scores), adjacency.shape[0])
def setUp(self) -> None:
"""Simple case for testing"""
self.adjacency = test_graph()
self.n = self.adjacency.shape[0]
self.k = 5
def test_options(self):
paris = Paris(weights='uniform')
adjacency = test_graph()
dendrogram = paris.fit_transform(adjacency)
n = adjacency.shape[0]
self.assertEqual(dendrogram.shape, (n - 1, 4))
def test_errors(self):
adjacency = test_graph()
with self.assertRaises(ValueError):
ForceAtlas().fit(adjacency, pos_init=np.ones((5, 7)))
def test_louvain_hierarchy(self):
lne = HLouvainEmbedding()
lne.fit(test_graph())
self.assertTupleEqual(lne.embedding_.shape, (10, 2))
def test_init(self):
adjacency = test_graph()
with self.assertRaises(ValueError):
Polynome(adjacency, np.array([]))
def test_options(self):
adjacency = test_graph()
ward = Ward(embedding_method=Spectral(3))
dendrogram = ward.fit_transform(adjacency)
self.assertEqual(dendrogram.shape, (adjacency.shape[0] - 1, 4))
