def test_infomap(self): if infomap is not None: g = get_string_graph() coms = algorithms.infomap(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) if os.path.exists(".tree"): os.remove(".tree") h = nx.DiGraph() for e in g.edges(): h.add_edge(e[0], e[1], weight=3) coms = algorithms.infomap(h) 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) if os.path.exists(".tree"): os.remove(".tree") gg = ig.Graph(directed=True) gg.add_vertices([v for v in h.nodes()]) gg.add_edges([(u, v) for u, v in h.edges()]) coms = algorithms.infomap(gg) 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) if os.path.exists(".tree"): os.remove(".tree")
def benchmark_scores(samplesize=1): """Generate score data sets.""" v = [ 0.1 ] #, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7] f = open("benchmarks-opt1.csv", "w+") f.write("Spinglass, InfoMap, Leiden, Mu\n") # Read and evaluate graph optimizer scores for set 1. for mu in v: print(mu) for i in range(samplesize): filename = "./Graphs/lfr-graph{}-mu-{}.txt".format(i, mu) g = nx.read_gpickle(filename) scorespinglass = 0 try: # There is a probability the optimizers fail, indicated by -1 scorespinglass = benchmark_score(g, algorithms.spinglass(g)) except: scorespinglass = -1 scoreinfomap = 0 try: scoreinfomap = benchmark_score(g, algorithms.infomap(g)) except: scoreinfomap = -1 scoreleiden = benchmark_score(g, algorithms.leiden(g)) vals = (scorespinglass, scoreinfomap, scoreleiden, mu) f.write("%f, %f, %f, %f\n" % vals) print("%f, %f, %f, %f" % vals) f.close() f = open("benchmarks-opt2.csv", "w+") f.write("Spinglass, InfoMap, Leiden, Mu\n") # Read and evaluate graph optimizer scores for set 2. for mu in v: print(mu) for i in range(samplesize): filename = "./Graphs/lfr2-graph{}-mu-{}.txt".format(i, mu) g = nx.read_gpickle(filename) scorespinglass = 0 try: scorespinglass = benchmark_score(g, algorithms.spinglass(g)) except: scorespinglass = -1 scoreinfomap = 0 try: scoreinfomap = benchmark_score(g, algorithms.infomap(g)) except: scoreinfomap = -1 scoreleiden = benchmark_score(g, algorithms.leiden(g)) vals = (scorespinglass, scoreinfomap, scoreleiden, mu) f.write("%f, %f, %f, %f\n" % vals) print("%f, %f, %f, %f" % vals) f.close()
def test_infomap(self): g = get_string_graph() coms = algorithms.infomap(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) if os.path.exists(".tree"): os.remove(".tree")
def test_infomap(self): if infomap is not None: g = get_string_graph() coms = algorithms.infomap(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) if os.path.exists(".tree"): os.remove(".tree") h = nx.DiGraph() for e in g.edges(): h.add_edge(e[0], e[1], weight=3) coms = algorithms.infomap(h) 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) if os.path.exists(".tree"): os.remove(".tree")
def community_discoverying_algorithms(g): """ All Community Discovery algorithms generate as result a NodeClustering object, allowing also for the generation of a JSON representation of the results. Then evaluate the clusters with fitness functions (ex. synthetic representation of its min/max/mean/std values ORD communitiy-wise value) """ print("Starting computing angel_coms") angel_coms = algorithms.angel(g.to_undirected(), threshold=0.25) write_on_file(angel_coms, "communities/angel.json") draw_community_graph(g, angel_coms, "communities/angel.png") print("END") print("Starting computing infomap_coms") infomap_coms = algorithms.infomap(g.to_undirected()) write_on_file(infomap_coms, "communities/infomap.json") draw_community_graph(g, infomap_coms, "communities/infomap.png") print("END") print("Starting computing louvain_coms") louvain_coms = algorithms.louvain(g.to_undirected()) write_on_file(louvain_coms, "communities/louvain.json") draw_community_graph(g, louvain_coms, "communities/louvain.png") print("END") print("Starting computing labelpropagation_coms") labelpropagation_coms = algorithms.label_propagation(g.to_undirected()) write_on_file(labelpropagation_coms, "communities/labelpropagation.json") draw_community_graph(g, labelpropagation_coms, "communities/labelpropagation.png") print("END") draw_cluster_violin_map( [angel_coms, infomap_coms, louvain_coms, labelpropagation_coms]) draw_cluster_heatmap( [angel_coms, infomap_coms, louvain_coms, labelpropagation_coms]) draw_plot_map([angel_coms, infomap_coms], 1) draw_plot_map([angel_coms, louvain_coms], 2) draw_plot_map([angel_coms, labelpropagation_coms], 3) draw_plot_map([infomap_coms, louvain_coms], 4) draw_plot_map([infomap_coms, labelpropagation_coms], 5) draw_plot_map([louvain_coms, labelpropagation_coms], 6)
def split_graph(graph, max_nodes_per_sub_graph=10000): """ Split a given graph into subgraphs using infomap's community detection algorithm :param graph: OSMNX graph to split :param max_nodes_per_sub_graph: :return: """ if len(graph.nodes) <= max_nodes_per_sub_graph: return [graph] final_graphs = [] to_split = set() to_split.add(graph.copy()) while len(to_split) > 0: g = to_split.pop() initial_nodes = set(g.nodes) community_map = algorithms.infomap(g).to_node_community_map() communities = {} for node, comm_ids in community_map.items(): comm_id = comm_ids[0] comm_set = communities.get(comm_id, set()) comm_set.add(node) communities[comm_id] = comm_set for comm_id, comm_set in communities.items(): sub_g = g.copy() sub_g.remove_nodes_from(initial_nodes - comm_set) # Remove nodes that are not in the community sub_g = osmnx.utils_graph.get_largest_component(sub_g, strongly=True) if len(sub_g.nodes) > max_nodes_per_sub_graph: to_split.add(sub_g) else: final_graphs.append(sub_g) return final_graphs
def infomap(self): template = pd.read_csv("data/communities_template.node", " ", header='infer') saveTo = "Results/Communities/" + self.name + "_infomap_communities.node" G = nx.Graph(self.g) result = algorithms.infomap(G) modularity = result.newman_girvan_modularity().score significance = result.significance().score communities = result.to_node_community_map() n_communities = list(communities.values())[-1][0] + 1 print("\nInfomap Algorithm: ") print("#Communities: ", n_communities) print("Modularity: ", modularity) print("Significance: ", significance) b = self.get_ordered_communities(communities) template['Infomap'] = b print("\n") template['Degree'] = [v for v in self.centrality] template['RegionName'] = self.region_names pd.DataFrame.to_csv(template, saveTo, " ", header=False, index=False) return b
def cluster_community_from_graph(graph=None, graph_sparse_matrix=None, method="louvain", directed=False, **kwargs): """Detect communities based on graph inputs and selected methods with arguments passed in kwargs. Parameters ---------- graph : [type], optional [description], by default None graph_sparse_matrix : [type], optional [description], by default None method : str, optional [description], by default "louvain" Returns ------- [type] NodeClustering Object from CDlib Raises ------ ImportError [description] ValueError [description] NotImplementedError [description] """ logger = LoggerManager.get_main_logger() logger.info("Detecting communities on graph...") try: import networkx as nx from cdlib import algorithms except ImportError: raise ImportError( "You need to install the excellent package `cdlib` if you want to use louvain or leiden " "for clustering.") if graph is not None: # highest priority pass elif graph_sparse_matrix is not None: logger.info("Converting graph_sparse_matrix to networkx object", indent_level=2) # if graph matrix is with weight, then edge attr "weight" stores weight of edges graph = nx.convert_matrix.from_scipy_sparse_matrix( graph_sparse_matrix, edge_attribute="weight") for i in range(graph_sparse_matrix.shape[0]): if not (i in graph.nodes): graph.add_node(i) else: raise ValueError("Expected graph inputs are invalid") if directed: graph = graph.to_directed() else: graph = graph.to_undirected() if method == "leiden": initial_membership, weights = None, None if "initial_membership" in kwargs: logger.info( "Detecting community with initial_membership input from caller" ) initial_membership = kwargs["initial_membership"] if "weights" in kwargs: weights = kwargs["weights"] if initial_membership is not None: main_info( "Currently initial_membership for leiden has some issue and thus we ignore it. " "We will support it in future.") initial_membership = None coms = algorithms.leiden(graph, weights=weights, initial_membership=initial_membership) elif method == "louvain": if "resolution" not in kwargs: raise KeyError("resolution not in louvain input parameters") # if "weight" not in kwargs: # raise KeyError("weight not in louvain input parameters") if "randomize" not in kwargs: raise KeyError("randomize not in louvain input parameters") resolution = kwargs["resolution"] weight = "weight" randomize = kwargs["randomize"] coms = algorithms.louvain(graph, weight=weight, resolution=resolution, randomize=randomize) elif method == "infomap": coms = algorithms.infomap(graph) else: raise NotImplementedError("clustering algorithm not implemented yet") logger.finish_progress(progress_name="Community clustering with %s" % (method)) return coms
filtered_entities = {k:v for k,v in entities.items() if v != []} print(filtered_entities) #creates graph G = nx.Graph(filtered_entities) print(G.nodes()) print(G.edges()) #remove outliers/self-loops G.remove_edges_from(nx.selfloop_edges(G)) G = nx.k_core(G,k=2) #Louvain/infomap algorithm and graph plot #coms = algorithms.louvain(G) coms = algorithms.infomap(G) pos = nx.spring_layout(G) viz.plot_community_graph(G, coms, figsize=(8, 8), node_size=200, plot_overlaps=False, plot_labels=True, cmap=None, top_k=None, min_size=None) viz.plot_network_clusters(G, coms, position=None, figsize=(8, 8), node_size=200, plot_overlaps=False, plot_labels=False, cmap=None, top_k=None, min_size=None) #converting this to an nx graph for calculations. mod = evaluation.modularity_density(G,coms) print(mod) #calculating modularity mod = evaluation.modularity_density(G,coms) print(mod) #calculating purity #communities = eva(G, coms) #pur = evaluation.purity(communities)
nx.draw_networkx_edges(unet, pos) nx.draw_networkx_labels(unet,pos) plt.show() #%% evaluation from cdlib import evaluation evaluation.newman_girvan_modularity(unet,algorithms.greedy_modularity(unet)) evaluation.newman_girvan_modularity(unet,algorithms.louvain(unet)) #%% infmpCommunity = algorithms.infomap(net).communities import matplotlib.pyplot as plt from matplotlib.colors import rgb2hex palette = plt.get_cmap("Set1") pos=nx.kamada_kawai_layout(net) # for each group colorIndex=0 for community in infmpCommunity: # from rgb to hexadecimal chosenColor=rgb2hex(palette(colorIndex)) nx.draw_networkx_nodes(net,pos, nodelist=community, #nodes chosen node_color=chosenColor)
def info_map(G): return algorithms.infomap(G)
nmi_infomap, nmi_eigenvector, nmi_louvian, \ nmi_leiden, nmi_walktrap, nmi_markov, nmi_greedy, nmi_propagation = ([] for i in range(8)) for mixing_parameter in np.arange(0.1, 1, 0.1): ############################### LFR ############################### LFR_G = generate_lfr(mixing_parameter) set_comm = {frozenset(LFR_G.nodes[v]["community"]) for v in LFR_G} comm_list = [node_set for node_set in set_comm] true_labels = extract_communities_list(comm_list) nx.draw(LFR_G, nx.spring_layout(LFR_G), node_color=true_labels, cmap=plt.cm.get_cmap('rainbow'), node_size=30) comm_num = len(true_labels) plt.title('len: %i', comm_num) plt.show() ############################### Infomap ############################### infomap_partition = cd.infomap(LFR_G) # Partition graph with Infomap infomap_labels = extract_communities_list(infomap_partition.communities) nmi_infomap.append(normalized_mutual_info_score(true_labels, infomap_labels)) ############################### Leading Eigenvector ############################### eigenvector_partition = cd.eigenvector(LFR_G) eigenvector_labels = extract_communities_list(eigenvector_partition.communities) nmi_eigenvector.append(normalized_mutual_info_score(true_labels, eigenvector_labels)) ############################### Louvian ############################### louvian_partition = cd.louvain(LFR_G) louvian_labels = extract_communities_list(louvian_partition.communities) nmi_louvian.append(normalized_mutual_info_score(true_labels, louvian_labels)) ############################### Leiden ############################### leiden_partition = cd.leiden(LFR_G)
dt_g = nx.get_node_attributes(G, 'value') true_communities = list(dt_g.values()) true_partitions = get_partitions(true_communities) plt.figure() plt.title("Amazon books labeled by political map (right, left, neutral)") nx.draw(G, nx.spring_layout(G), node_color=true_communities, cmap=plt.cm.get_cmap('brg'), node_size=70) plt.show() ############################### Infomap ############################### start_time = time.time() infomap_partition = cd.infomap(G) infomap_time = time.time() - start_time infomap_communities = extract_communities_list(infomap_partition.communities, G) infomap_partitions = get_partitions(infomap_communities) nmi_infomap = normalized_mutual_info_score(true_communities, infomap_communities) ari_infomap = adjusted_rand_score(true_communities, infomap_communities) vi_infomap = variation_of_information(true_partitions, infomap_partitions) ############################### Leading Eigenvector ############################### start_time = time.time() eigenvector_partition = cd.eigenvector(G) eifenvector_time = time.time() - start_time eigenvector_communities = extract_communities_list( eigenvector_partition.communities, G)