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_leiden(self): g = get_string_graph() coms = algorithms.leiden(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 test_f1(self): g = nx.karate_club_graph() leiden_communities = leiden(g) louvain_communities = louvain(g) score = evaluation.f1(louvain_communities, leiden_communities) self.assertIsInstance(score, evaluation.MatchingResult)
def test_variation_of_information(self): g = nx.karate_club_graph() leiden_communities = leiden(g) louvain_communities = louvain(g) score = evaluation.variation_of_information(louvain_communities, leiden_communities) self.assertLessEqual(score, np.log(g.number_of_nodes())) self.assertGreaterEqual(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_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 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_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)
# %% [markdown] # # from cdlib import algorithms, viz import networkx as nx import matplotlib.pyplot as plt from graspy.plot import heatmap g = nx.LFR_benchmark_graph(1000, 3, 1.5, 0.7, min_community=20, average_degree=5) coms = algorithms.leiden(g) def nc_to_label(coms): nodelist = [] comlist = [] com_map = coms.to_node_community_map() for node, assignment in com_map.items(): assignment = assignment[0] nodelist.append(node) comlist.append(assignment) return nodelist, comlist nodelist, labels = nc_to_label(coms) adj = nx.to_numpy_array(g, nodelist=nodelist) heatmap(adj, inner_hier_labels=labels)
coms_graph.append(value) count_louvain = 0 l = [] for i in coms.communities: l.append(i) for j in coms_graph: if i == j: count_louvain += 1 l.remove(i) print("Equal community:", count_louvain) print("#total communtites in louvain:", len(coms.communities)) print("#total communtites in gra:", len(coms_graph)) # Running the Leiden algorithm in NetworkX coms_leiden = algorithms.leiden(G, weights='weight') # Comparison between Louvain and Leiden count_leiden = 0 l = [] for i in coms_leiden.communities: l.append(i) for j in coms_graph: if i == j: count_leiden += 1 l.remove(i) print("Equal community:", count_leiden) print("#total communtites in leiden:", len(coms_leiden.communities)) print("#total communtites in graph:", len(coms_graph))
exec('clust_kwargs = {' + options.additional_options + '}') # This allows inject custom arguments for each clustering method f = open(options.input, 'r') g = nx.Graph() for line in f: fields = line.strip("\n").split("\t") if (options.bipartite): g.add_node(fields[0], bipartite=0) g.add_node(fields[1], bipartite=1) g.add_edge(fields[0], fields[1], weight=float(fields[2])) print(g.number_of_nodes()) print(g.number_of_edges()) if (options.method == 'leiden'): communities = algorithms.leiden(g, weights='weight', **clust_kwargs) elif (options.method == 'louvain'): communities = algorithms.louvain(g, weight='weight', **clust_kwargs) elif (options.method == 'cpm'): communities = algorithms.cpm(g, weights='weight', **clust_kwargs) elif (options.method == 'der'): communities = algorithms.der(g, **clust_kwargs) elif (options.method == 'edmot'): communities = algorithms.edmot(g, **clust_kwargs) elif (options.method == 'eigenvector'): communities = algorithms.eigenvector(g, **clust_kwargs) elif (options.method == 'gdmp2'): communities = algorithms.gdmp2(g, **clust_kwargs) elif (options.method == 'greedy_modularity'): communities = algorithms.greedy_modularity(g, weight='weight',
############################### Louvian ############################### start_time = time.time() louvian_partition = cd.louvain(G) louvian_time = time.time() - start_time louvian_communities = extract_communities_list(louvian_partition.communities, G) louvian_partitions = get_partitions(louvian_communities) nmi_louvian = normalized_mutual_info_score(true_communities, louvian_communities) ari_louvian = adjusted_rand_score(true_communities, louvian_communities) vi_louvian = variation_of_information(true_partitions, louvian_partitions) ############################### Leiden ############################### start_time = time.time() leiden_partition = cd.leiden(G) leiden_time = time.time() - start_time leiden_communities = extract_communities_list(leiden_partition.communities, G) leiden_partitions = get_partitions(leiden_communities) nmi_ledien = normalized_mutual_info_score(true_communities, leiden_communities) ari_leiden = adjusted_rand_score(true_communities, leiden_communities) vi_leiden = variation_of_information(true_partitions, leiden_partitions) ############################### Walktrap ############################### start_time = time.time() walktrap_partition = cd.walktrap(G) walktrap_time = time.time() - start_time walktrap_communities = extract_communities_list(walktrap_partition.communities, G) walktrap_partitions = get_partitions(walktrap_communities) nmi_walktrap = normalized_mutual_info_score(true_communities,
def make_community_plot(edges, fname): """Draw network of countries with color by community.""" # Create network edges = edges[edges["Share"] > WEIGHT_CUTOFF] G = nx.from_pandas_edgelist(edges, edge_attr=["Share"], create_using=nx.DiGraph()) label_map = {c: c.replace(" ", "\n") for c in G.nodes()} G = nx.relabel_nodes(G, label_map) # Compute communities assignments = [] communities = algorithms.leiden(G).communities for i, countries in enumerate(communities): for c in countries: assignments.append((c, i)) # Assign colors to communities assignments = sorted(assignments) cmap = plt.cm.Accent norm = mpl.colors.Normalize(vmin=0, vmax=len(communities)) colors = [mpl.colors.to_hex(cmap(norm(c))) for _, c in assignments] # Set plotting data weights = [d["Share"]**(1 / 4) * 2 for u, v, d in G.edges(data=True)] pos = { 'Australia': array([0.7, -0.5]), 'Austria': array([1.6, 0.2]), 'Argentina': array([-0.7, 1.4]), 'Belgium': array([-0.8, -1.2]), 'Canada': array([2.22575671, 1.5610229]), 'Chile': array([-0.8, 0.5]), 'China': array([1.61854788, 1.32449744]), 'Czechia': array([1.9, -0.2]), 'Denmark': array([0.55, 0.0]), 'Estonia': array([0.9, -1.4]), 'Finland': array([1.2, -0.8]), 'France': array([0.5, -1.4]), 'Greece': array([-0.62007952, -0.29862564]), 'Germany': array([0.52524589, 0.29605388]), 'Ireland': array([-1.40267759, -0.95125886]), 'Israel': array([-0.27088909, 1.67098229]), 'Italy': array([-1.27570138, -0.39003278]), 'Japan': array([1.3, 2.2]), 'Hungary': array([-0.58183462, 0.3007111]), 'Lithuania': array([-0.18229243, -0.87409266]), 'Mexico': array([-1.04499295, 0.8088658]), 'Netherlands': array([-0.2, -0.1]), 'New\nZealand': array([1.13144828, -0.40443485]), 'Norway': array([0.4, -1.1]), 'Poland': array([-0.5, 0.9]), 'Portugal': array([-1.56933095, -0.02689741]), 'Romania': array([-0.1, -1.5]), 'Russia': array([-0.9, 1.]), 'Singapore': array([0.9, -0.1]), 'Slovakia': array([1.6, 0.5]), 'Slovenia': array([-1.25634143, -1.17581249]), 'South\nAfrica': array([-0.88135798, -0.66437467]), 'South\nKorea': array([0.55168098, 2.029026]), 'Spain': array([-1.43098845, 0.50067855]), 'Switzerland': array([0.23053752, 0.15402242]), 'Sweden': array([0.90539775, -1.05909741]), 'Taiwan': array([1.8, 2.0]), 'Turkey': array([-0.2, 0.3]), 'United\nKingdom': array([0.1, -0.65800041]), 'United\nStates': array([1.0, 1.2]) } # Make plot fig, ax = plt.subplots(figsize=(15, 15)) nodelist = sorted(G.nodes()) nx.draw(G, ax=ax, nodelist=nodelist, pos=pos, with_labels=True, font_size=12, node_size=2000, node_color=colors, width=weights, edge_color="grey", arrows=True, font_weight="bold", arrowstyle='-|>', arrowsize=12, connectionstyle="arc3, rad = 0.1") plt.savefig(fname, bbox_inches="tight") plt.clf()
def leiden(G): return algorithms.leiden(G)
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX # Dosyaların okunduğu ve grafa edgelerin eklendiği kısım. for entry in os.listdir(retweet_folder): print('reading retweet edges from file (' + entry + ')...') if os.path.isfile(os.path.join(retweet_folder, entry)): fhand = open(os.path.join(retweet_folder, entry)) for line in fhand: lst = line.strip().split(',') if len(lst[0]) == 0 or len(lst[1]) == 0: continue G.add_weighted_edges_from([(lst[0], lst[1], int(lst[2]))]) print("file reading complete!") print("node count " + str(len(G.nodes()))) print("\n") # LEIDEN ALGORITHMS lei_com = algorithms.leiden(G) community_size(lei_com.communities) #get_communities(lei_com.communities) # Check Results Folder if os.path.isdir("results") == False: os.mkdir("results") print("Results Folder is created \n") writeComToFile(lei_com.communities)
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) leiden_labels = extract_communities_list(leiden_partition.communities) nmi_leiden.append(normalized_mutual_info_score(true_labels, louvian_labels)) ############################### Walktrap ############################### walktrap_partition = cd.walktrap(LFR_G) walktrap_labels = extract_communities_list(walktrap_partition.communities) nmi_walktrap.append(normalized_mutual_info_score(true_labels, walktrap_labels)) ############################### Markov Clustering ############################### markov_partition = cd.markov_clustering(LFR_G) markov_labels = extract_communities_list(markov_partition.communities) nmi_markov.append(normalized_mutual_info_score(true_labels, markov_labels)) ############################### Greedy ############################### greedy_partition = cd.greedy_modularity(LFR_G)
def plot_nmi_scores(N, sigma_list, samples_num, MRA_type): nmi_scores = {"leiden": [], "louvain": [], "leading_eigenvector": [], "spinglass": [], "walktrap": [], "infomap": [], "greedy": [], "LPA": [], "betweenness": [], "kmeans": []} time_scores = {"leiden": [], "louvain": [], "leading_eigenvector": [], "spinglass": [], "walktrap": [], "infomap": [], "greedy": [], "LPA": [], "betweenness": [], "kmeans": []} snr_list = [] for sigma in sigma_list: nmi_samples = {"leiden": [], "louvain": [], "leading_eigenvector": [], "spinglass": [], "walktrap": [], "infomap": [], "greedy": [], "LPA": [], "betweenness": [], "kmeans": []} time_samples = {"leiden": [], "louvain": [], "leading_eigenvector": [], "spinglass": [], "walktrap": [], "infomap": [], "greedy": [], "LPA": [], "betweenness": [], "kmeans": []} snr_samples = [] print("sigma: {}".format(sigma)) # Calculate NMI score for a number (samples_num) of random graphs for i in range(samples_num): # Generate appropriate MRA graph if MRA_type == "Rect_Trian": K=2 nx_G, ig_G, true_labels, x, noise, y = MRA_Graphs.MRA_Rect_Trian(N, L=50, K=K, sigma=sigma) snr_samples.append(calculate_snr(x, noise, 50)) elif MRA_type == "Standard_Normal": K=2 nx_G, ig_G, true_labels, x, noise, y = MRA_Graphs.MRA_StandardNormal(N, L=50, K=K, sigma=sigma) snr_samples.append(calculate_snr(x, noise, 50)) else: K=2 nx_G, ig_G, true_labels, x, noise, y = MRA_Graphs.MRA_CorrelatedNormal(N, L=51, K=K, a=1, b=2, choice=1, sigma=sigma) snr_samples.append(calculate_snr(x, noise, 51)) print("true: {}".format(true_labels)) start = time.time() kmeans_labels = Kmeans.kmeans(y, K) end = time.time() time_samples["kmeans"].append(end - start) print("kmeans: {}".format(kmeans_labels)) nmi_samples["kmeans"].append(normalized_mutual_info_score(true_labels, kmeans_labels)) start = time.time() leiden = cd.leiden(nx_G, weights='weight') end = time.time() time_samples["leiden"].append(end-start) leiden_labels = extract_communities_list(leiden.communities, N) print("leiden: {}".format(leiden_labels)) nmi_samples["leiden"].append(normalized_mutual_info_score(true_labels, leiden_labels)) start = time.time() louvain = cd.louvain(nx_G, weight='weight') end = time.time() time_samples["louvain"].append(end - start) louvain_labels = extract_communities_list(louvain.communities, N) print("louvain: {}".format(louvain_labels)) nmi_samples["louvain"].append(normalized_mutual_info_score(true_labels, louvain_labels)) # Convert NetworkX graph to Igraph graph #G = ig.Graph.from_networkx(G) #start = time.time() #infomap = ig.Graph.community_infomap(ig_G, edge_weights='weight') #end = time.time() #time_samples["infomap"].append(end - start) #print("infomap: {}".format(infomap.membership)) #nmi_samples["infomap"].append(normalized_mutual_info_score(true_labels, infomap.membership)) start = time.time() greedy = ig.Graph.community_fastgreedy(ig_G, weights='weight') end = time.time() time_samples["greedy"].append(end - start) greedy = greedy.as_clustering() print("greedy: {}".format(greedy.membership)) nmi_samples["greedy"].append(normalized_mutual_info_score(true_labels, greedy.membership)) #start = time.time() #LPA = ig.Graph.community_label_propagation(ig_G, weights='weight') #end = time.time() #time_samples["LPA"].append(end - start) #print("LPA: {}".format(LPA.membership)) #nmi_samples["LPA"].append(normalized_mutual_info_score(true_labels, LPA.membership)) #start = time.time() #betweenness = ig.Graph.community_edge_betweenness(ig_G, weights='weight') #end = time.time() #time_samples["betweenness"].append(end - start) #betweenness = betweenness.as_clustering() #print("betweenness: {}".format(betweenness.membership)) #nmi_samples["betweenness"].append(normalized_mutual_info_score(true_labels, betweenness.membership)) start = time.time() leading_eigenvector = ig.Graph.community_leading_eigenvector(ig_G, weights="weight") end = time.time() time_samples["leading_eigenvector"].append(end - start) print("leading eigenvector: {}".format(leading_eigenvector.membership)) nmi_samples["leading_eigenvector"].append(normalized_mutual_info_score(true_labels, leading_eigenvector.membership)) #multilevel = ig.Graph.community_multilevel(G, weights="weight") #print("multilevel: {}".format(multilevel.membership)) #nmi_samples["multilevel"].append(normalized_mutual_info_score(true_labels, multilevel.membership)) #start = time.time() #spinglass = ig.Graph.community_spinglass(ig_G, weights="weight") #end = time.time() #time_samples["spinglass"].append(end - start) #print("spinglass: {}".format(spinglass.membership)) #nmi_samples["spinglass"].append(normalized_mutual_info_score(true_labels, spinglass.membership)) start = time.time() walktrap = ig.Graph.community_walktrap(ig_G, weights="weight") end = time.time() time_samples["walktrap"].append(end - start) walktrap = walktrap.as_clustering() print("walktrap: {}".format(walktrap.membership)) nmi_samples["walktrap"].append(normalized_mutual_info_score(true_labels, walktrap.membership)) # Set NMI score for each algrorithm #nmi_scores["infomap"].append(np.mean(nmi_samples["infomap"])) nmi_scores["greedy"].append(np.mean(nmi_samples["greedy"])) #nmi_scores["LPA"].append(np.mean(nmi_samples["LPA"])) #nmi_scores["betweenness"].append(np.mean(nmi_samples["betweenness"])) nmi_scores["kmeans"].append(np.mean(nmi_samples["kmeans"])) nmi_scores["leiden"].append(np.mean(nmi_samples["leiden"])) nmi_scores["louvain"].append(np.mean(nmi_samples["louvain"])) nmi_scores["leading_eigenvector"].append(np.mean(nmi_samples["leading_eigenvector"])) #nmi_scores["multilevel"].append(np.mean(nmi_samples["multilevel"])) #nmi_scores["spinglass"].append(np.mean(nmi_samples["spinglass"])) nmi_scores["walktrap"].append(np.mean(nmi_samples["walktrap"])) #time_scores["infomap"].append(np.round(np.mean(time_samples["infomap"]), 2)) time_scores["greedy"].append(np.round(np.mean(time_samples["greedy"]), 2)) #time_scores["LPA"].append(np.round(np.mean(time_samples["LPA"]), 2)) #time_scores["betweenness"].append(np.round(np.mean(time_samples["betweenness"]), 2)) time_scores["kmeans"].append(np.round(np.mean(time_samples["kmeans"]), 2)) time_scores["leiden"].append(np.round(np.mean(time_samples["leiden"]), 2)) time_scores["louvain"].append(np.round(np.mean(time_samples["louvain"]), 2)) time_scores["leading_eigenvector"].append(np.mean(time_samples["leading_eigenvector"])) # nmi_scores["multilevel"].append(np.mean(nmi_samples["multilevel"])) #time_scores["spinglass"].append(np.round(np.mean(time_samples["spinglass"]), 2)) time_scores["walktrap"].append(np.round(np.mean(time_samples["walktrap"]), 2)) snr_list.append(np.mean(snr_samples)) #plt.plot(np.flip(time_scores["infomap"]), color='#575757', # marker='o', mfc='#f1362b', mec='#f1362b' ,label='infomap') plt.plot(np.flip(time_scores["greedy"]), color='#575757', marker='x', mfc='#17c436', mec='#17c436', label='greedy') #plt.plot(np.flip(time_scores["LPA"]), color='#575757', # marker='o', mfc='#d9a000', mec='#d9a000', label='LPA') #plt.plot(np.flip(time_scores["betweenness"]), color='#575757', # marker='o', mfc='#532ce9', mec='#532ce9', label='betweenness') plt.plot(np.flip(time_scores["kmeans"]), color='#575757', marker='o', mfc='#d9a000', mec='#d9a000', label='kmeans', linewidth=3) plt.plot(np.flip(time_scores["leiden"]), color='#575757', marker='x', mfc='#532ce9', mec='#532ce9', label='leiden') plt.plot(np.flip(time_scores["louvain"]), color='#575757', marker='x', mfc='#f1362b', mec='#f1362b', label='louvain') plt.plot(np.flip(time_scores["leading_eigenvector"]), color='#575757', marker='x', mfc='#d9a000', mec='#d9a000', label='leading eigenvector') plt.plot(np.flip(time_scores["walktrap"]), color='#575757', marker='x', mfc='#02B789', mec='#02B789', label='walktrap') #plt.plot(np.flip(time_scores["spinglass"]), color='#575757', # marker='o', mfc='#02B789', mec='#02B789', label='spinglass') plt.xticks(list(range(len(snr_list))), np.flip(np.floor(snr_list).astype('int'))) plt.title("{} MRA\n (K={}, Signal Length={}, Runs Number={})".format(MRA_type, K, 50, 10)) plt.xlabel("SNR[dB]") plt.ylabel("Time[s]") plt.legend() plt.grid() plt.show() #plt.plot(np.flip(nmi_scores["infomap"]), color='#575757', # marker='o', mfc='#f1362b', mec='#f1362b', label="infomap") plt.plot(np.flip(nmi_scores["greedy"]), color='#575757', marker='x', mfc='#17c436', mec='#17c436', label="greedy") #plt.plot(np.flip(nmi_scores["LPA"]), color='#575757', # marker='o', mfc='#d9a000', mec='#d9a000', label="LPA") #plt.plot(np.flip(nmi_scores["betweenness"]), color='#575757', # marker='o', mfc='#532ce9', mec='#532ce9', label="betweenness") plt.plot(np.flip(nmi_scores["kmeans"]), color='#575757', marker='o', mfc='#d9a000', mec='#d9a000', label='kmeans', linewidth=3) plt.plot(np.flip(nmi_scores["leiden"]), color='#575757', marker='x', mfc='#532ce9', mec='#532ce9', label="leiden") plt.plot(np.flip(nmi_scores["louvain"]), color='#575757', marker='x', mfc='#f1362b', mec='#f1362b', label="louvain") plt.plot(np.flip(nmi_scores["leading_eigenvector"]), color='#575757', marker='x', mfc='#d9a000', mec='#d9a000', label="leading eigenvector") #plt.plot(np.flip(nmi_scores["multilevel"]), label="multilevel") plt.plot(np.flip(nmi_scores["walktrap"]), color='#575757', marker='x', mfc='#02B789', mec='#02B789', label="walktrap") #plt.plot(np.flip(nmi_scores["spinglass"]), color='#575757', # marker='x', mfc='#02B789', mec='#02B789', label="spinglass") #plt.xscale("symlog", linthresh=np.mean(np.abs(snr_list))) #plt.xscale("symlog", linthresh=0.1) plt.xticks(list(range(len(snr_list))), np.flip(np.floor(snr_list).astype('int'))) plt.title("{} MRA\n (K={}, Signal Length={}, Runs Number={})".format(MRA_type,K,50,10)) plt.xlabel("SNR[dB]") plt.ylabel("NMI") plt.legend() plt.grid() plt.show()
# ATTENZIONE: richiede qualche minuto # # CONSIGLIO: passare alla cella successiva che carica i risultati da file # In[30]: accuracy_spinglass = 0 accuracy_eigenvector = 0 accuracy_leiden = 0 accuracy_cpm = 0 accuracy_rber_pots = 0 for i in range(10): result_spinglass_tmp = algorithms.spinglass(g1) result_eigenvector_tmp = algorithms.eigenvector(g1) result_leiden_tmp = algorithms.leiden(g1) result_cpm_tmp = algorithms.cpm(g1, resolution_parameter=.00018) result_rber_pots_tmp = algorithms.rber_pots(g1, resolution_parameter=.32) #definizione colonne che servono per calcolare l'accuracy nodes1['community_spinglass'] = -1 for i in range(len(result_spinglass_tmp.communities)): for j in result_spinglass_tmp.communities[i]: nodes1.loc[j, 'community_spinglass'] = i nodes1['community_eigenvector'] = -1 for i in range(len(result_eigenvector_tmp.communities)): for j in result_eigenvector_tmp.communities[i]: nodes1.loc[j, 'community_eigenvector'] = i nodes1['community_leiden'] = -1 for i in range(len(result_leiden_tmp.communities)): for j in result_leiden_tmp.communities[i]:
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
"leading_eigenvector": [], "multilevel": [], "spinglass": [], "walktrap": [] } inter_weights = { "leiden": [], "louvain": [], "leading_eigenvector": [], "multilevel": [], "spinglass": [], "walktrap": [] } # Execute algorithms and get inter and intra edges weights leiden = cd.leiden(G, weights='weight') intra_weights["leiden"], inter_weights["leiden"] = \ partition_edges_by_communities(weights_dict.items(), leiden.communities) louvain = cd.louvain(G, weight='weight') intra_weights["louvain"], inter_weights["louvain"] = \ partition_edges_by_communities(weights_dict.items(), louvain.communities) # Convert NetworkX graph to Igraph graph G = ig.Graph.from_networkx(G) leading_eigenvector = ig.Graph.community_leading_eigenvector(G, weights="weight") leading_eigenvector_communities = create_communities_2darray( leading_eigenvector.membership) intra_weights["leading_eigenvector"], inter_weights["leading_eigenvector"] = \ partition_edges_by_communities(weights_dict.items(), leading_eigenvector_communities) multilevel = ig.Graph.community_multilevel(G, weights="weight") multilevel_communities = create_communities_2darray(multilevel.membership)