def test_undirected(self):
self.karate_club = karate_club()
adjacency: sparse.csr_matrix = karate_club()
self.diffusion.fit(adjacency, {0: 0, 1: 1, 2: 0.5})
score = self.diffusion.scores_
self.assertTrue(np.all(score <= 1 + self.tol) and np.all(score >= 0 - self.tol))
self.naive_diff.fit(adjacency, {0: 0, 1: 1, 2: 0.5})
score = self.diffusion.scores_
self.assertTrue(np.all(score <= 1 + self.tol) and np.all(score >= 0 - self.tol))
def test_error_on_parallel_FW(self):
adjacency = karate_club()
self.assertRaises(ValueError,
distance,
adjacency,
n_jobs=2,
method='FW')
def test_options(self):
adjacency = karate_club()
# resolution
louvain = Louvain(resolution=2)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 7)
# tolerance
louvain = Louvain(resolution=2, tol_aggregation=0.1)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 12)
# shuffling
louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 9)
# aggregate graph
louvain = Louvain(return_aggregate=True)
labels = louvain.fit_transform(adjacency)
n_labels = len(set(labels))
self.assertEqual(louvain.adjacency_.shape, (n_labels, n_labels))
# aggregate graph
Louvain(n_aggregations=1, sort_clusters=False).fit(adjacency)
def test_options_with_64_bit(self):
adjacency = karate_club()
# force 64-bit index
adjacency.indices = adjacency.indices.astype(np.int64)
adjacency.indptr = adjacency.indptr.astype(np.int64)
# resolution
louvain = Louvain(resolution=2)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 7)
# tolerance
louvain = Louvain(resolution=2, tol_aggregation=0.1)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 12)
# shuffling
louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)
labels = louvain.fit_transform(adjacency)
self.assertEqual(len(set(labels)), 9)
# aggregate graph
louvain = Louvain(return_aggregate=True)
labels = louvain.fit_transform(adjacency)
n_labels = len(set(labels))
self.assertEqual(louvain.aggregate_.shape, (n_labels, n_labels))
# aggregate graph
Louvain(n_aggregations=1, sort_clusters=False).fit(adjacency)
# check if labels are 64-bit
self.assertEqual(labels.dtype, np.int64)
def test_niter(self):
adjacency = karate_club(metadata=False)
n = adjacency.shape[0]
seeds = {0: 0, 1: 1}
propagation = Propagation(n_iter=3)
labels = propagation.fit_transform(adjacency, seeds)
self.assertEqual(len(labels), n)
def test_options(self):
adjacency = karate_club()
self.assertEqual(
Triangles(parallelize=False).fit_transform(adjacency), 45)
self.assertEqual(
Triangles(parallelize=True).fit_transform(adjacency), 45)
def test_modularity(self):
adjacency = karate_club()
louvain_d = Louvain(modularity='dugue')
louvain_n = Louvain(modularity='newman')
labels_d = louvain_d.fit_transform(adjacency)
labels_n = louvain_n.fit_transform(adjacency)
self.assertTrue((labels_d == labels_n).all())
louvain_p = Louvain(modularity='potts')
louvain_p.fit_transform(adjacency)
def test_push(self):
# test convergence by tolerance
adjacency = karate_club()
seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
pr = get_pagerank(adjacency,
damping_factor=0.85,
n_iter=100,
tol=1e-1,
solver='push',
seeds=seeds)
self.assertTrue(is_proba_array(pr))
def test_parallel(self):
adjacency = karate_club(metadata=False)
seeds = {0: 0, 1: 1}
clf1 = KNN(n_neighbors=1, n_jobs=None)
clf2 = KNN(n_neighbors=1, n_jobs=-1)
labels1 = clf1.fit_transform(adjacency, seeds)
labels2 = clf2.fit_transform(adjacency, seeds)
self.assertTrue(np.allclose(labels1, labels2))
def test_aggregation(self):
self.adjacency = karate_club()
paris = Paris()
self.dendrogram = paris.fit_transform(self.adjacency)
n_clusters = 5
dendrogram_, counts = aggregate_dendrogram(self.dendrogram,
n_clusters,
return_counts=True)
self.assertEqual(dendrogram_.shape,
(n_clusters - 1, self.dendrogram.shape[1]))
self.assertEqual(counts.sum(), self.dendrogram.shape[0] + 1)
def test_options(self):
adjacency = karate_club(metadata=False)
n = adjacency.shape[0]
seeds = {0: 0, 1: 1}
propagation = Propagation(n_iter=3, weighted=False)
labels = propagation.fit_transform(adjacency, seeds)
self.assertEqual(labels.shape, (n,))
for order in ['random', 'decreasing', 'increasing']:
propagation = Propagation(node_order=order)
labels = propagation.fit_transform(adjacency, seeds)
self.assertEqual(labels.shape, (n,))
def test_lanczos(self):
solver = LanczosEig('LM')
solver.fit(self.adjacency, 2)
self.assertEqual(len(solver.eigenvalues_), 2)
self.assertAlmostEqual(eigenvector_err(self.adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)
solver.fit(self.slr, 2)
self.assertEqual(len(solver.eigenvalues_), 2)
self.assertAlmostEqual(eigenvector_err(self.slr, solver.eigenvectors_, solver.eigenvalues_), 0)
adjacency = karate_club()
solver = LanczosEig('SM')
solver.fit(adjacency, 2)
self.assertEqual(len(solver.eigenvalues_), 2)
self.assertAlmostEqual(eigenvector_err(adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)
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_undirected(self):
self.louvain_high_resolution = Louvain(engine='python', resolution=2)
self.louvain_null_resolution = Louvain(engine='python', resolution=0)
self.karate_club = karate_club()
self.louvain.fit(self.karate_club)
labels = self.louvain.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.42, 2)
if is_numba_available:
self.louvain_numba.fit(self.karate_club)
labels = self.louvain_numba.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.42,
2)
self.louvain_high_resolution.fit(self.karate_club)
labels = self.louvain_high_resolution.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.34, 2)
self.louvain_null_resolution.fit(self.karate_club)
labels = self.louvain_null_resolution.labels_
self.assertEqual(labels.shape, (34, ))
self.assertEqual(len(set(self.louvain_null_resolution.labels_)), 1)
def test_modularity(self):
adjacency = karate_club()
labels = Louvain().fit_transform(adjacency)
self.assertAlmostEqual(0.42, modularity(adjacency, labels), places=2)
def test_default_options(self):
self.undirected: sparse.csr_matrix = karate_club()
spectral_clustering = SpectralClustering(embedding_dimension=3)
spectral_clustering.fit(self.undirected)
self.assertEqual(spectral_clustering.labels_.shape[0],
self.undirected.shape[0])
def test_invalid(self):
adjacency = karate_club()
louvain = Louvain(modularity='toto')
with self.assertRaises(ValueError):
louvain.fit(adjacency)
def test_graph(self):
adjacency = karate_club()
neighbors = get_neighbors(adjacency, 5)
neighbors_true = np.array([0, 6, 10, 16])
self.assertEqual(norm(neighbors - neighbors_true), 0)
def test_predecessors(self):
adjacency = karate_club()
_, predecessors = shortest_path(adjacency, return_predecessors=True)
self.assertTupleEqual(predecessors.shape, adjacency.shape)
def test_parallel(self):
adjacency = karate_club()
path1 = shortest_path(adjacency)
path2 = shortest_path(adjacency, n_jobs=-1)
self.assertTrue((path1 == path2).all())
def test_default_options(self):
self.adjacency: sparse.csr_matrix = karate_club()
spectral_ward = SpectralWard(embedding_dimension=3)
spectral_ward.fit(self.adjacency)
self.assertEqual(spectral_ward.dendrogram_.shape,
(self.adjacency.shape[0] - 1, 4))
def setUp(self):
self.adjacency: sparse.csr_matrix = karate_club()
self.house = house()
def setUp(self):
self.undirected: sparse.csr_matrix = karate_club()
self.directed: sparse.csr_matrix = painters()
self.bipartite: sparse.csr_matrix = movie_actor()
def test_parallel(self):
karate = karate_club()
truth = shortest_path(karate)
parallel = shortest_path(karate, n_jobs=None)
self.assertEqual(np.equal(truth, parallel).sum(), 34 ** 2)
def test_parallel(self):
adjacency = karate_club()
dist1 = distance(adjacency)
dist2 = distance(adjacency, n_jobs=-1)
self.assertTrue((dist1 == dist2).all())
def setUp(self):
paris = Paris()
adjacency = karate_club()
self.dendrogram = paris.fit_transform(adjacency)
