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)
