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)