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)
