def test_read_write_json(self): g = nx.karate_club_graph() communities = algorithms.louvain(g) readwrite.write_community_json(communities, "coms.json") communities_r = readwrite.read_community_json("coms.json") self.assertListEqual(communities.communities, communities_r.communities) os.remove("coms.json") communities = algorithms.louvain(g) readwrite.write_community_json(communities, "coms.gzip", zip=True) communities_r = readwrite.read_community_json("coms.gzip", zip=True) self.assertListEqual(communities.communities, communities_r.communities) os.remove("coms.gzip") communities = algorithms.frc_fgsn(g, 1, 0.5, 3) readwrite.write_community_json(communities, "coms.json") communities_r = readwrite.read_community_json("coms.json") self.assertListEqual(communities.communities, communities_r.communities) os.remove("coms.json") communities = algorithms.hierarchical_link_community(g) readwrite.write_community_json(communities, "coms.json") communities_r = readwrite.read_community_json("coms.json") self.assertListEqual(communities.communities, communities_r.communities) with open("coms.json") as f: cr = f.read() readwrite.read_community_from_json_string(cr) os.remove("coms.json")
def test_pquality_indexes(self): g = nx.karate_club_graph() communities = louvain(g) indexes = [ evaluation.normalized_cut, evaluation.internal_edge_density, evaluation.average_internal_degree, evaluation.fraction_over_median_degree, evaluation.expansion, evaluation.cut_ratio, evaluation.edges_inside, evaluation.conductance, evaluation.max_odf, evaluation.avg_odf, evaluation.flake_odf, evaluation.triangle_participation_ratio, evaluation.size, evaluation.avg_embeddedness, evaluation.scaled_density, evaluation.avg_distance, evaluation.hub_dominance, evaluation.avg_transitivity, evaluation.modularity_overlap ] for idx in indexes: res = idx(g, communities) self.assertIsInstance(res, evaluation.FitnessResult) for idx in indexes: try: res = idx(g, communities, summary=False) self.assertIsInstance(res, list) except: pass
def test_fitness_scores(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) self.assertIsInstance(coms.link_modularity().score, float) self.assertIsInstance(coms.normalized_cut(), evaluation.FitnessResult) self.assertIsInstance(coms.size(), evaluation.FitnessResult) self.assertIsInstance(coms.avg_embeddedness(), evaluation.FitnessResult) self.assertIsInstance(coms.avg_transitivity(), evaluation.FitnessResult) self.assertIsInstance(coms.hub_dominance(), evaluation.FitnessResult) self.assertIsInstance(coms.avg_distance(), evaluation.FitnessResult) self.assertIsInstance(coms.scaled_density(), evaluation.FitnessResult) self.assertIsInstance(coms.internal_edge_density(), evaluation.FitnessResult) self.assertIsInstance(coms.average_internal_degree(), evaluation.FitnessResult) self.assertIsInstance( coms.fraction_over_median_degree(), evaluation.FitnessResult ) self.assertIsInstance(coms.expansion(), evaluation.FitnessResult) self.assertIsInstance(coms.modularity_overlap(), evaluation.FitnessResult) self.assertIsInstance(coms.cut_ratio(), evaluation.FitnessResult) self.assertIsInstance(coms.edges_inside(), evaluation.FitnessResult) self.assertIsInstance(coms.conductance(), evaluation.FitnessResult) self.assertIsInstance(coms.max_odf(), evaluation.FitnessResult) self.assertIsInstance(coms.avg_odf(), evaluation.FitnessResult) self.assertIsInstance(coms.flake_odf(), evaluation.FitnessResult) self.assertIsInstance( coms.triangle_participation_ratio(), evaluation.FitnessResult ) self.assertIsInstance(coms.newman_girvan_modularity().score, float) self.assertIsInstance(coms.erdos_renyi_modularity().score, float) self.assertIsInstance(coms.modularity_density().score, float) self.assertIsInstance(coms.z_modularity().score, float) self.assertIsInstance(coms.surprise().score, float) self.assertIsInstance(coms.significance().score, float)
def test_louvain(self): g = get_string_graph() coms = algorithms.louvain(g) self.assertEqual(type(coms.communities), list) if len(coms.communities) > 0: self.assertEqual(type(coms.communities[0]), list) self.assertEqual(type(coms.communities[0][0]), str)
def densestCommunity(graph): '''Extracts the densest community of a graph, with Louvain algorithm. Input: - graph: weighted graph. Output: - graphDC: subgraph induced on the nodes of the densest community of the graph.''' # Louvain algorithm to extract communities from the graph NodeClustering = algorithms.louvain( graph, weight='weight', resolution=1., randomize=False) # Stores the maximum density found maxWeight = 0 dcs = [] # Initializes DCS node list # Iterates the communities, found in the alignment graph for i in NodeClustering.communities: # Extracts from graph a subgraph containing the nodes of community i Sg = graph.subgraph(i) # # Calculates the density dWs = densityWgraph(Sg) # If the actual calculated density is greater than the stored one if dWs > maxWeight: # The current density is stored as maximum maxWeight = dWs # And the subgraphs found are stored dcs = i.copy() # Found the community of graph with maximum density # Extracts from graph a community # containing the nodes of the maximum community stored in dcs graphDC = graph.subgraph(dcs) print("Densest Community of weighted graph --> nodes: ", len(graphDC.nodes), ", edges: ", len(graphDC.edges), "; density: ", maxWeight) # Returns DCS graph return graphDC
def compute_indexes(G: nx.Graph, method, negative, positive): if method == 'resource_allocation': return nx.resource_allocation_index( G, negative), nx.resource_allocation_index(G, positive) elif method == 'jaccard_coefficient': return nx.jaccard_coefficient(G, negative), nx.jaccard_coefficient( G, positive) elif method == 'adamic_adar': return nx.adamic_adar_index(G, negative), nx.adamic_adar_index( G, positive) elif method == 'preferential_attachment': return nx.preferential_attachment( G, negative), nx.preferential_attachment(G, positive) elif method == 'sorensen_neighbours': return ([(u, v, sorensen_index(G, u, v)) for u, v in negative], [(u, v, sorensen_index(G, u, v)) for u, v in positive]) elif method == 'community': c = louvain(G) commLabels = c.communities comms = c.to_node_community_map() return ([(u, v, community_index(G, u, v, commLabels, comms)) for u, v in negative], [(u, v, community_index(G, u, v, commLabels, comms)) for u, v in positive]) else: raise NameError('The given method is not supported')
def test_surprise(self): g = nx.karate_club_graph() communities = louvain(g) mod = evaluation.surprise(g, communities) self.assertLessEqual(mod.score, g.number_of_edges()) self.assertGreaterEqual(mod.score, 0)
def test_link_modularity(self): g = nx.karate_club_graph() communities = louvain(g) mod = evaluation.link_modularity(g, communities) self.assertLessEqual(mod.score, 1) self.assertGreaterEqual(mod.score, 0)
def test_closeness_simple(self): g = nx.karate_club_graph() lp_communities = label_propagation(g) louvain_communities = louvain(g) score = evaluation.partition_closeness_simple(louvain_communities, lp_communities) self.assertLessEqual(score.score, 1) self.assertGreaterEqual(score.score, 0)
def test_adjusted_mutual(self): g = nx.karate_club_graph() leiden_communities = leiden(g) louvain_communities = louvain(g) score = evaluation.adjusted_mutual_information(louvain_communities, leiden_communities) self.assertLessEqual(score, 1) self.assertGreaterEqual(score, 0)
def test_read_write(self): g = nx.karate_club_graph() communities = algorithms.louvain(g) readwrite.write_community_csv(communities, "coms.csv") communities_r = readwrite.read_community_csv("coms.csv", nodetype=int) self.assertListEqual(communities.communities, communities_r.communities) os.remove("coms.csv")
def test_f1(self): g = nx.karate_club_graph() lp_communities = label_propagation(g) louvain_communities = louvain(g) score = evaluation.f1(louvain_communities, lp_communities) self.assertIsInstance(score, evaluation.MatchingResult)
def test_adjusted_rand(self): g = nx.karate_club_graph() lp_communities = label_propagation(g) louvain_communities = louvain(g) score = evaluation.adjusted_rand_index(louvain_communities, lp_communities) self.assertLessEqual(score.score, 1) self.assertGreaterEqual(score.score, 0)
def test_variation_of_information(self): g = nx.karate_club_graph() lp_communities = label_propagation(g) louvain_communities = louvain(g) score = evaluation.variation_of_information(louvain_communities, lp_communities) self.assertLessEqual(score.score, np.log(g.number_of_nodes())) self.assertGreaterEqual(score.score, 0)
def get_temporal_network_clustering(): tc = TemporalClustering() for t in range(10): g = nx.erdos_renyi_graph(100, 0.05) coms = algorithms.louvain(g) tc.add_clustering(coms, t) return tc
def test_remap_node_community(self): g = get_string_graph() nodes = list(g.nodes()) g, node_map = utils.nx_node_integer_mapping(g) coms = algorithms.louvain(g) coms_remap = utils.remap_node_communities(coms.communities, node_map) flat_list = [item for sublist in coms_remap for item in sublist] self.assertListEqual(sorted(nodes), sorted(flat_list))
def test_nmi(self): g = nx.karate_club_graph() louvain_communities = louvain(g) lp_communities = label_propagation(g) score = evaluation.normalized_mutual_information(louvain_communities, lp_communities) self.assertLessEqual(score.score, 1) self.assertGreaterEqual(score.score, 0)
def test_nf1(self): g = nx.karate_club_graph() leiden_communities = leiden(g) louvain_communities = louvain(g) score = evaluation.nf1(louvain_communities, leiden_communities) self.assertLessEqual(score, 1) self.assertGreaterEqual(score, 0)
def test_onmi(self): g = nx.karate_club_graph() leiden_communities = leiden(g) louvain_communities = louvain(g) score = evaluation.overlapping_normalized_mutual_information(louvain_communities, leiden_communities) self.assertLessEqual(score, 1) self.assertGreaterEqual(score, 0)
def extractLouvain(W): try: print("Start Modularity") coms = algorithms.louvain(W, weight='weight', resolution=1., randomize=False) except Exception as inst: print(type(inst)) # the exception instance print(inst.args) # arguments stored in .args print(inst) return -1 return coms
def test_plot_sim_matrix(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) coms2 = algorithms.label_propagation(g) viz.plot_sim_matrix([coms, coms2], evaluation.adjusted_mutual_information) plt.savefig("cluster.pdf") os.remove("cluster.pdf")
def test_to_json(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) self.assertIsInstance(coms, NodeClustering) js = coms.to_json() self.assertIsInstance(js, str) self.assertEqual(coms.node_coverage, 1.0) coms = algorithms.frc_fgsn(g, 0.5, 0.3, 1) js = coms.to_json() self.assertIsInstance(js, str)
def get_temporal_network_clustering(): tc = TemporalClustering() for t in range(10): g = nx.erdos_renyi_graph(100, 0.05) coms = algorithms.louvain(g) # simulating named clustering nc = NamedClustering({i: c for i, c in enumerate(coms.communities)}, g, coms.method_name) tc.add_clustering(nc, t) return tc
def test_pquality_indexes(self): g = nx.karate_club_graph() communities = louvain(g) indexes = [evaluation.normalized_cut, evaluation.internal_edge_density, evaluation.average_internal_degree, evaluation.fraction_over_median_degree, evaluation.expansion, evaluation.cut_ratio, evaluation.edges_inside, evaluation.conductance, evaluation.max_odf, evaluation.avg_odf, evaluation.flake_odf, evaluation.triangle_participation_ratio, evaluation.size] for idx in indexes: res = idx(g, communities) self.assertIsInstance(res, evaluation.FitnessResult)
def test_endntm(self): G = nx.karate_club_graph() coms_l = [ algorithms.louvain(G), algorithms.label_propagation(G), algorithms.walktrap(G), ] coms = algorithms.endntm(G, coms_l) self.assertEqual(type(coms.communities), list) if len(coms.communities) > 0: self.assertEqual(type(coms.communities[0]), list) self.assertEqual(type(coms.communities[0][0]), int)
def test_comparison(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) coms2 = algorithms.leiden(g) self.assertIsInstance(coms.normalized_mutual_information(coms2), float) self.assertIsInstance( coms.overlapping_normalized_mutual_information(coms2), float) self.assertIsInstance(coms.omega(coms2), float) self.assertIsInstance(coms.f1(coms2), evaluation.MatchingResult) self.assertIsInstance(coms.nf1(coms2), float) self.assertIsInstance(coms.adjusted_mutual_information(coms2), float) self.assertIsInstance(coms.adjusted_rand_index(coms2), float) self.assertIsInstance(coms.variation_of_information(coms2), float)
def test_community_graph(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) viz.plot_community_graph(g, coms) plt.savefig("cg.pdf") os.remove("cg.pdf") coms = algorithms.angel(g, 0.25) viz.plot_community_graph(g, coms, plot_overlaps=True, plot_labels=True) plt.savefig("cg.pdf") os.remove("cg.pdf")
def test_plot_com_stat(self): g = nx.karate_club_graph() coms = algorithms.louvain(g) coms2 = algorithms.label_propagation(g) viz.plot_com_stat([coms, coms2], evaluation.size) plt.savefig("cluster.pdf") os.remove("cluster.pdf") viz.plot_com_stat(coms, evaluation.size) plt.savefig("cluster.pdf") os.remove("cluster.pdf")
def community_vaccination(self, A, param=[8, 0.5]): # Use an algo to detect communities. communities = algo.louvain(nx.Graph(A)).communities # Get the nodes with highest "out_community" links. opt1 = target_nodes(communities, param[0], out_community=True)[0] opt2 = self.select_nodes(A, state=0, nei_thres=0) opt = np.intersect1d(opt1, opt2) idx = np.random.choice(opt, ceil(len(opt) * param[1]), replace=False) A[idx, :] = 0 A[:, idx] = 0 self.initialize_nodes(idx, state=0) self.vacci_num = len(idx) return A
def smart_walk(chord_graph, start_chord=None, progression_length=4, out_threshold=0.85): communities = algorithms.louvain(chord_graph.to_undirected()) chord_path = [] visited_chords = [] current_chord = start_chord if current_chord == None: pagerank = np.array( list(nx.get_node_attributes( chord_graph, "pagerank", ).values())) pagerank = np.array(pagerank) / sum( pagerank) # normalizing pagerank values to get probability distr. current_chord = np.random.choice(a=list(chord_graph.nodes), p=pagerank) for chord_step in range(progression_length): chord_path.append(current_chord) visited_chords.append(current_chord) neighboring_chords = list(chord_graph.neighbors(current_chord)) probabilities = [] possible_next_chords = [] rand = np.random.uniform(0, 1) if rand < out_threshold: community_index = [ True if current_chord in community else False for community in communities.communities ].index(True) possible_next_chords = [ chord for chord in neighboring_chords if chord in communities.communities[community_index] ] if len(possible_next_chords) == 0: possible_next_chords = neighboring_chords else: possible_next_chords = neighboring_chords + visited_chords for chord in possible_next_chords: probabilities.append( int(chord_graph.in_degree(chord, weight='weight'))) probabilities = np.array(probabilities) / sum(probabilities) current_chord = np.random.choice(possible_next_chords, p=probabilities) return chord_path