def test_termination():
# ensure termination of asyn_lpa_communities in two cases
# that led to an endless loop in a previous version
test1 = nx.karate_club_graph()
test2 = nx.caveman_graph(2, 10)
test2.add_edges_from([(0, 20), (20, 10)])
asyn_lpa_communities(test1)
asyn_lpa_communities(test2)
def label_propagation(G, weight='weight'):
'''Community detection using label propagation algorithm.
Parameters
----------
G : networkx.graph
weight : edge attribute if G is weighted or None if G is unweighted
Returns
-------
list_communities : list
A list of sets, and each set contains vertices in one community.
Notes
-----
This function only deals with weighted and unweighted undirected graph.
'''
# H is the undirected version of graph G
H = G.to_undirected()
if weight is None:
communities = community.label_propagation_communities(H)
else:
communities = community.asyn_lpa_communities(H, weight=weight)
list_communities = list(communities)
return list_communities
def find_communities_citations_based(top_x_communities=100):
"""Returns a dict mapping an author_id to a community_id they belong to.
The communities are created based on a citations graph.
The community_id are sorted from largest to smallest with only top x
communities created."""
# Fetch the data from the db
with connection.cursor() as cursor:
# author | cited_author | amount_of_cites
cursor.execute('''select app1.author_id, app2.author_id, count(*)
from author_paper_pairs app1
join publications p1 on app1.paper_id = p1.id
join cites c on p1.id = c.paper_id
join publications p2 on p2.id = c.cited_paper_id
join author_paper_pairs app2 on app2.paper_id = p2.id
group by app1.author_id, app2.author_id;''')
author_cites_author = cursor.fetchall()
# Create a directed graph and populate it with weighed edges
g = nx.DiGraph()
g.add_weighted_edges_from(author_cites_author)
# Run community detection algorithm (asynchronous label propagation)
communities = sorted(nxcom.asyn_lpa_communities(g, weight='weight'),
key=len, reverse=True)
return communities_to_dict(communities, top_x_communities)
def label_propagation(network):
coms_iter = nxcom.asyn_lpa_communities(network)
communities = []
for nodes in iter(coms_iter):
communities.append(list(nodes))
return communities
def apply_lpa(UG):
partition_list = list(community.asyn_lpa_communities(UG))
partition_map = list_to_dict(partition_list)
try:
mod = nx.community.quality.modularity(UG, partition_list)
except:
mod = 0
return mod, partition_map, partition_list
def LabelPropagationAlgorithm(ground_truth_path, dataset_path, size):
#initialize gorund truth
ground_truth_set = groundTruth(ground_truth_path)
#create network from edge list
G = nx.read_edgelist(dataset_path)
#list to store the result of each iteration
iteration_accuracy = []
iteration_time = []
#define number of iterations
iterations = 10
for i in range(iterations):
#call label propagation algorithm and time it
start = time.time()
res_lpa = community.asyn_lpa_communities(G)
end = time.time()
accuracy = round(percentage_of_nodes(ground_truth_set, res_lpa, size),
2)
execTime = round((end - start) * 1000, 2)
#append results (accuracy and time) for the current iteration
iteration_accuracy.append(accuracy)
iteration_time.append(execTime)
#calculate and return average accuracy and average execution time
avg_accuracy = round(sum(iteration_accuracy) / len(iteration_accuracy), 2)
avg_time = round(sum(iteration_time) / len(iteration_time), 2)
f = open("results.txt", "a")
f.write("\nLabel Propagation Algorithm:\n")
f.write("Algorithm is non-deterministic\n")
f.write("Results are shown for 10 iterations\n")
if (ground_truth_path == "datasets/Karate/karate-club-labels.txt"):
f.write("Dataset: Karate Club\n")
elif (ground_truth_path ==
"datasets/email-Eu-Core/email-Eu-core-department-labels.txt"):
f.write("Dataset: Email Eu Core\n")
elif (ground_truth_path == "datasets/YouTube/youtube.top5000.txt"):
f.write("Dataset: YouTube\n")
elif (ground_truth_path == "datasets/Amazon/amazon.top5000.txt"):
f.write("Dataset: Amazon\n")
elif (ground_truth_path == "datasets/Football/football-comms.txt"):
f.write("Dataset: College Football\n")
f.write("{:<20s}{:<20s}\n".format("Accuracy[%]", "Run Time[ms]"))
for i in range(iterations):
f.write("{:<20f}{:<20f}".format(iteration_accuracy[i],
iteration_time[i]))
f.write("\n")
f.write("\n{:<20s}{:<20s}\n".format("Average accuracy", "Average time"))
f.write("{:<20f}{:<20f}\n\n".format(avg_accuracy, avg_time))
f.close()
def _check_communities(self, G, expected):
"""Checks that the communities computed from the given graph ``G``
using the :func:`~networkx.asyn_lpa_communities` function match
the set of nodes given in ``expected``.
``expected`` must be a :class:`set` of :class:`frozenset`
instances, each element of which is a node in the graph.
"""
communities = asyn_lpa_communities(G)
result = {frozenset(c) for c in communities}
assert_equal(result, expected)
def adjacency_matrix_top_n():
"""
adjacentcy matrix dara
API format: /adjacency-matrix?size=<number of nodes>
@param size: top n number of nodes. default value is 100
{
'nodes': [
{"group": 0, "index": 95, "name": "casualiama"},
{...},
...
],
'links': [
{"source": "islam", "target": "worldnews", "value": 27},
{...},
...
]
}
"""
size = request.args.get('size', default=100, type=int)
if 'multidigraph' not in globals:
get_nodes_query = '''
MATCH (n:Subreddit)-[LINK]->(Subreddit)
RETURN n.id AS id
'''
nodes_result = execute_query(get_nodes_query)
get_links_query = '''
MATCH (s)-[LINK]->(t)
RETURN s.id AS source, t.id AS target
'''
links_result = execute_query(get_links_query)
# nx multi-directional graph
globals['multidigraph'] = make_multi_directed_graph(nodes=nodes_result,
links=links_result)
G = globals['multidigraph'].copy()
# downsizing using eigenvector centrality score
ecs_G = eigenvector_centrality(G=G, size=size)
# communities detection - label propagation algorithm
communities_generator = community.asyn_lpa_communities(ecs_G)
# update data
index = 0
for c in communities_generator:
comm = list(c)
for i, n in enumerate(comm):
G.add_node(n, index=index, name=n, group=i)
index += 1
distinct_edges = list(dict.fromkeys(list(G.edges())))
ret_edges = [{
'source': s,
'target': t,
'value': len(G.get_edge_data(s, t))
} for (s, t) in distinct_edges]
ret_nodes = [data for (n, data) in list(G.nodes(data=True))]
return jsonify({'nodes': ret_nodes, 'links': ret_edges})
def _check_communities(self, G, expected):
"""Checks that the communities computed from the given graph ``G``
using the :func:`~networkx.asyn_lpa_communities` function match
the set of nodes given in ``expected``.
``expected`` must be a :class:`set` of :class:`frozenset`
instances, each element of which is a node in the graph.
"""
communities = asyn_lpa_communities(G)
result = {frozenset(c) for c in communities}
assert_equal(result, expected)
def get_alp_communities(self):
comm_iterator = community.asyn_lpa_communities(self.ugc,
weight='weight')
comm_part = list(comm_iterator)
node_comm = {}
for comm_i, node_set in enumerate(comm_part):
for node in node_set:
node_comm[node] = comm_i
comm_mod = community.quality.modularity(G=self.ugc,
communities=comm_part,
weight='weight')
self.communities['comm.ALP_%.2f'%comm_mod] = \
node_comm
def edge_bundling_top_n_v2():
"""
version 2 - using multi-directional graph
edge bundling graph on top selected nodes
API format: /edge-bundling?size=<number of nodes>
@param size: top n number of nodes. default value is 100
[
{'name': '61.pcmasterrace', 'size': 323, 'imports': ["0.personalfinance", "0.self", ...]},
{...}
...
]
"""
size = request.args.get('size', default=100, type=int)
if 'multidigraph' not in globals:
get_nodes_query = '''
MATCH (n:Subreddit)-[LINK]->(Subreddit)
RETURN n.id AS id
'''
nodes_result = execute_query(get_nodes_query)
get_links_query = '''
MATCH (s)-[LINK]->(t)
RETURN s.id AS source, t.id AS target
'''
links_result = execute_query(get_links_query)
# nx multi-directional graph
globals['multidigraph'] = make_multi_directed_graph(nodes=nodes_result,
links=links_result)
G = globals['multidigraph'].copy()
# downsizing using eigenvector centrality score
ecs_G = eigenvector_centrality(G=G, size=size)
# communities detection - label propagation algorithm
communities_generator = community.asyn_lpa_communities(ecs_G)
# update name attr
for c in communities_generator:
comm = list(c)
for i, n in enumerate(comm):
G.add_node(n, name=str(i) + '.' + str(n))
# update size and imports attrs
ret_nodes = list(G.nodes(data=True))
for n in ret_nodes:
(node, attrs) = n
attrs['size'] = G.out_degree(node)
attrs['imports'] = list(
dict.fromkeys([
nx.get_node_attributes(G, 'name')[t]
for (s, t) in list(G.out_edges(node))
]))
return jsonify([data for (n, data) in ret_nodes])
def clusters_lpa(evs, node_list, verbose=True):
import networkx as nx
from networkx.algorithms import community
if len(evs) > 0:
# clustering: create network
if verbose:
logging.info("Create network")
evs_e = evs[["in_gene", "out_gene", "branch_support"]]
evs_n = nx.convert_matrix.from_pandas_edgelist(
evs_e,
source="in_gene",
target="out_gene",
edge_attr="branch_support")
evs_n.add_nodes_from(node_list)
# clustering: asynchronous label propagation
if verbose:
logging.info("Find communities LPA")
clu_c = community.asyn_lpa_communities(evs_n, seed=11)
clu_c = {frozenset(c) for c in clu_c}
if verbose:
logging.info("Find communities LPA num clusters = %i" % len(clu_c))
clu_c_clu = [i for i, cluster in enumerate(clu_c) for node in cluster]
clu_c_noi = [
node for i, cluster in enumerate(clu_c) for node in cluster
]
else:
if verbose:
logging.info("There are no speciation events in this tree.")
clu_c_noi = node_list
clu_c_clu = [i for i in range(len(node_list))]
# clustering: save output
clu = pd.DataFrame({
"node": clu_c_noi,
"cluster": clu_c_clu,
},
columns=["node", "cluster"])
if verbose:
logging.info("Find communities LPA | num clustered genes = %i" %
len(clu))
return clu
def fit_predict(self, X, y):
"""Performs clustering on y and returns list of label lists
Builds a label graph using the provided graph builder's `transform` method
on `y` and then detects communities using the selected `method`.
Sets :code:`self.weights_` and :code:`self.graph_`.
Parameters
----------
X : None
currently unused, left for scikit compatibility
y : scipy.sparse
label space of shape :code:`(n_samples, n_labels)`
Returns
-------
arrray of arrays of label indexes (numpy.ndarray)
label space division, each sublist represents labels that are in that community
"""
edge_map = self.graph_builder.transform(y)
if self.graph_builder.is_weighted:
self.weights_ = dict(weight=list(edge_map.values()))
else:
self.weights_ = dict(weight=None)
self.graph_ = nx.Graph()
for n in range(y.shape[1]):
self.graph_.add_node(n)
for e, w in edge_map.items():
self.graph_.add_edge(e[0], e[1], weight=w)
if self.method == 'louvain':
partition_dict = community.best_partition(self.graph_)
memberships = [partition_dict[i] for i in range(y.shape[1])]
return np.array(
_membership_to_list_of_communities(
memberships,
1 + max(memberships)
)
)
else:
return np.array([list(i) for i in asyn_lpa_communities(self.graph_, 'weight')])
def fit_predict(self, X, y):
"""Performs clustering on y and returns list of label lists
Builds a label graph using the provided graph builder's `transform` method
on `y` and then detects communities using the selected `method`.
Sets :code:`self.weights_` and :code:`self.graph_`.
Parameters
----------
X : None
currently unused, left for scikit compatibility
y : scipy.sparse
label space of shape :code:`(n_samples, n_labels)`
Returns
-------
arrray of arrays of label indexes (numpy.ndarray)
label space division, each sublist represents labels that are in that community
"""
edge_map = self.graph_builder.transform(y)
if self.graph_builder.is_weighted:
self.weights_ = dict(weight=list(edge_map.values()))
else:
self.weights_ = dict(weight=None)
self.graph_ = nx.Graph()
for n in range(y.shape[1]):
self.graph_.add_node(n)
for e, w in edge_map.items():
self.graph_.add_edge(e[0], e[1], weight=w)
if self.method == 'louvain':
partition_dict = community.best_partition(self.graph_)
memberships = [partition_dict[i] for i in range(y.shape[1])]
return np.array(
_membership_to_list_of_communities(memberships,
1 + max(memberships)))
else:
return np.array(
[list(i) for i in asyn_lpa_communities(self.graph_, 'weight')])
def create_figure(truth):
''' Create image '''
graph = nx.read_edgelist('datasets/karate/edges.txt')
communities = list(community.asyn_lpa_communities(graph))
communities = convert_communities(communities)
edgecolors = [COLORS[i] for i in truth]
nodecolors = [COLORS[i] for i in communities]
position = nx.spring_layout(graph)
nx.draw(graph,
position,
node_color=nodecolors,
edgecolors=edgecolors,
linewidths=2)
# plt.axis('off')
# plt.subplots_adjust(top=5)
plt.suptitle(f"Zachary karate network compared to ground-truth")
plt.savefig('plots/karate-graph.png', bbox_inches='tight')
def part_b_nx(adapters):
s_adapters = sorted(adapters)
device_joltage = s_adapters[-1] + 3
G = create_graph(s_adapters, device_joltage)
# Remove "linear" edges to split the graph into components
edges_to_remove = find_graph_cuts(G)
G.remove_edges_from(edges_to_remove)
#nx.nx_agraph.write_dot(G, "cut-graph.dot")
# Iterate over components of graph
result = 1
for G_c in nxcomm.asyn_lpa_communities(G):
if len(G_c) > 1:
paths = list(nx.all_simple_paths(G, min(G_c), max(G_c)))
result *= len(paths)
return result
def do_clustering(self):
if len(self.clusters) == 0 or self.clusterid != str(id(self)):
self.clusterid = str(id(self))
self.build_nx_graph()
clusters = list(asyn_lpa_communities(self.graph, weight="weight"))
new_clusters = []
for c in clusters:
new_clusters.append([])
for el in c:
if self.nodes_inv[el].startswith("event_id="):
new_clusters[-1].append(self.events_corr_inv[self.nodes_inv[el]])
if len(new_clusters[-1]) == 0:
del new_clusters[-1]
new_clusters = sorted(new_clusters, key=lambda x: len(x), reverse=True)
self.clusters = {}
for i in range(len(new_clusters)):
self.clusters["Cluster " + self.fill_string(str(i + 1)) + " (" + str(len(new_clusters[i])) + ")"] = \
new_clusters[i]
clusters_keys = sorted(list(self.clusters.keys()))
self.clustersrepr = "@@@".join(clusters_keys)
def label_propagation(G, weight='weight', iterNum=6):
'''Community detection using label propagation algorithm.
Parameters
----------
G : networkx.graph
weight : edge attribute if G is weighted or None if G is unweighted
iterNum : number to repeat label propagation algorithm
Returns
-------
list_communities : list
A list of sets, and each set contains vertices in one community.
Notes
-----
This function only deals with weighted and unweighted undirected graph.
'''
# H is the undirected version of graph G
H = G.to_undirected()
max_modularity = float('-inf')
for i in range(iterNum):
if weight is None:
cur_list_communities = list(
community.label_propagation_communities(H))
else:
cur_list_communities = list(
community.asyn_lpa_communities(H, weight=weight))
cur_modularity = quality.modularity(H, cur_list_communities)
if (cur_modularity > max_modularity):
list_communities = cur_list_communities
max_modularity = cur_modularity
return list_communities
import matplotlib.pyplot as plt
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
# https://medium.com/@sddkal/random-walks-on-adjacency-matrices-a127446a6777#:~:text=A%20random%20walk%20is%20a,can%20perform%20a%20random%20walk.
# %%
# G = nx.karate_club_graph()
# G = nx.barbell_graph(5, 2)
# # G = nx.bull_graph()
# # G = nx.generators.erdos_renyi_graph(10, 0.5)
# # G = nx.generators.cubical_graph()
# G = generator.planted_partition_graph(4, 50, p_in=0.9, p_out=0.05)
G, pos = generate_benchmark_graph(250,0.1)
pos = nx.spring_layout(G)
true_partition_map = community_louvain.best_partition(G)
lpa_prt = extract_partition_map(algorithms.asyn_lpa_communities(G))
communities = extract_community_map(true_partition_map)
nx.draw_networkx(G, pos, edgecolors="black", node_size=600, cmap=plt.cm.RdYlBu, node_color=list(true_partition_map.values()))
# %%
def random_walk(a, i, iters):
# a -> adj
# i -> starting row
walk = np.zeros(iters+1) # holds transitions
walk[0] = i
elements = np.arange(a.shape[0]) # for our graph [0,1,2,3]
c_index = i # current index for this iteration
for k in range(iters):
count = 0 # count of transitions
probs = a[c_index].reshape((-1,)) # probability of transitions
def get_communities(self, station_df):
import networkx as nx
import networkx.algorithms.community as nx_comm
g_communities_ = []
try:
''' sample the graph '''
g_simple_ = self.get_simple_graph(station_df)
if nx.is_empty(g_simple_):
raise ValueError(
'A simple graph with %d stations was not created' %
station_df.shape[0])
if self.name == 'ASYNC-LPA': #asyn_lpa_communities
g_communities_ = list(
nx_comm.asyn_lpa_communities(g_simple_,
weight=self.weight,
seed=self.seed))
elif self.name == 'LPC': #label_propagation_communities
g_communities_ = list(
nx_comm.label_propagation_communities(g_simple_))
elif self.name == 'GREEDY': # greedy_modularity_communities
g_communities_ = list(
nx_comm.greedy_modularity_communities(g_simple_))
elif self.name == 'NAIVE-GREEDY': #_naive_greedy_modularity_communities
g_communities_ = list(
nx_comm._naive_greedy_modularity_communities(g_simple_))
elif self.name == 'LUKES': # lukes_partitioning
# TODO: create MST of g_simple first but removing the mimum weigted edge doesn't seem right
g_communities_ = list(
nx_comm.lukes_partitioning(
g_simple_,
edge_weight=self.weight,
max_size=self.maximum_node_weight))
elif self.name == 'ASYNC-FLUID': # asyn_fluidc
# TODO: create complete graph for g_simple but a complete graph would not work
g_communities_ = list(
nx_comm.asyn_fluidc(g_simple_,
k=15,
max_iter=300,
seed=self.seed))
elif self.name == 'GIRVAN-NEWMAN': # girvan_newman
# g_communities_ = list(nx_comm.girvan_newman(g_simple_))
# tmp_communities = nx_comm.girvan_newman(g_simple_)
# g_communities_ = next(tmp_communities)
g_communities_ = list(next(nx_comm.girvan_newman(g_simple_)))
# print(list(g_communities_))
else:
raise AttributeError("something was not right")
# g_simple_ = self.set_graph_cluster_labels(g_simple_, g_communities_)
if isinstance(g_communities_, list): #len(g_communities_)>0
g_simple_ = self.set_graph_cluster_labels(
g_simple_, g_communities_)
#d return g_simple_, g_communities_
except Exception as err:
print("Class community_detection [get_communities] Error message:",
err)
return g_simple_, g_communities_
# g=nx.fast_gnp_random_graph(8,0.7)
# g=nx.windmill_graph(8,4)
N = len(g)
W = np.zeros((N, N))
for i in g:
print(i, end="-> ")
for j in nx.neighbors(g, i):
print(j, end=" ")
W[i][j] = 1
W[j][i] = 1
print()
# networkx community detection
gmc = list(greedy_modularity_communities(g))
alc = list(asyn_lpa_communities(g))
lpac = list(label_propagation_communities(g))
asfl = list(asyn_fluidc(g, 3))
# inititalization
anchorList = set([])
U = {}
U[N] = np.zeros(N)
randomFirstAnchor = random.randint(0, N - 1)
anchorList.add(randomFirstAnchor)
U[randomFirstAnchor] = np.zeros(N)
phi = 0.25
itermax = 15
K = 1
adjacentNodes = {}
for i in range(N):
def test_seed_argument(self):
G = nx.Graph(["ab", "ac", "bc", "de", "df", "fe"])
ground_truth = {frozenset("abc"), frozenset("def")}
communities = asyn_lpa_communities(G, seed=1)
result = {frozenset(c) for c in communities}
assert result == ground_truth
def func_propagation(graph):
# cm = nx_comm.label_propagation_communities(graph)
cm = nx_comm.asyn_lpa_communities(graph)
cm = tuple(set(e) for e in cm)
return cm
def calculate_community():
cate = list(community.asyn_lpa_communities(G, 'weight'))
center=(0.5, 0.5),
scale=0.5,
k=1 / len(graph)**0.1,
seed=1)
# pos = nx.kamada_kawai_layout(graph, center=(0.5, 0.5), scale=0.5)
# Base edges
nx.draw_networkx_edges(graph, pos=pos, width=0.2)
# Bridges
if type(graph) is not nx.DiGraph and nx.has_bridges(graph):
nx.draw_networkx_edges(graph,
edgelist=list(nx.bridges(graph)),
pos=pos,
width=3,
alpha=0.5,
edge_color="r")
# Nodes with colors
groups = list(asyn_lpa_communities(graph, weight="h"))
colors = [[state in com for com in groups].index(True) for state in graph]
nx.draw_networkx_nodes(graph, pos=pos, node_color=colors, cmap="tab20")
# Labels
nx.draw_networkx_labels(graph, pos, font_size=10)
if type(graph) is nx.DiGraph:
sorts = list(reversed(list(topological_sort(graph))))
plt.show()
# return nx.draw_networkx(G,
# pos,
# edge_color="black",
# with_labels=False,
# node_size=50,
# cmap=plt.cm.viridis,
# node_color=list(partition.values()) if partition else None,
# ax=ax)
# %%
print(f"Computing the ground truth of the LFR graph")
G, pos = generate_benchmark_graph(250,0.1)
true_partition_map, communities = extract_true_communities(G)
communities = algorithms.greedy_modularity_communities(G)
cnm_partition_map = extract_partition_map(communities)
communities = algorithms.asyn_lpa_communities(G)
lpa_partition_map = extract_partition_map(communities)
louvain_partition_map = community_louvain.best_partition(G)
#%%
print(f"Drawing the the LFR graphs")
fig, ax = plt.subplots(2, 2)
fig.set_size_inches(10, 10)
ax[0][0].set_title(f"Initial Graph", fontsize=10)
ax[0][0].set_axis_off()
ax[0][1].set_title(f"Ground-Truth", fontsize=10)
ax[0][1].set_axis_off()
# ax[0][1].set_title(f"Louvain", fontsize=10)
# ax[0][1].set_axis_off()
ax[1][0].set_title(f"Greedy Max Modularity ", fontsize=10)
ax[1][0].set_axis_off()
def get_communities_async_label_propagation(G):
return list(community.asyn_lpa_communities(G))
def add_asyn_lpa_communities(graph, weight=None, seed=None):
communities_result = nx_community.asyn_lpa_communities(graph, weight, seed)
_nx_community_data_to_graph(graph, communities_result)
return graph
def test_seed_argument(self):
G = nx.Graph(['ab', 'ac', 'bc', 'de', 'df', 'fe'])
ground_truth = {frozenset('abc'), frozenset('def')}
communities = asyn_lpa_communities(G, seed=1)
result = {frozenset(c) for c in communities}
assert_equal(result, ground_truth)
""" Creating the graph given the nodes and edges """
nodes = data["nodes"]
for i in nodes:
g.add_node(i["label"])
for i in data_read:
g.add_edge(find_node(i["properties"]["start"]),
find_node(i["properties"]["end"]),
frequency=int(i["frequency"]))
""" For saving the graph object """
# with open('graph.pkl', 'wb') as f:
# pickle.dump(g, f)
""" Directed Community detection methods """
# communities_generator = community.girvan_newman(g)
communities_generator = community.asyn_lpa_communities(g)
""" Undirected community detection methods """
# communities_generator = community.kernighan_lin_bisection(g)
# communities_generator = community.k_clique_communities(g,2)
# communities_generator = community.label_propagation_communities(g)
# communities_generator = community.greedy_modularity_communities(g) #Remains
# communities_generator = community.asyn_fluidc(g,2) #Remains
""" For Girvan-Newman algo """
# top_level_communities = next(communities_generator)
# next_level_communities = next(communities_generator)
""" For remaining algos """
next_level_communities = communities_generator
next_level_communities = sorted(map(sorted, next_level_communities))
""" Writing clusters detected to the schema """
counter = 0
def find_communities(nnodes, edges, alg, params=None):
def membership2cs(membership):
cs = {}
for i, m in enumerate(membership):
cs.setdefault(m, []).append(i)
return cs.values()
def connected_subgraphs(G: nx.Graph):
for comp in nx.connected_components(G):
sub = nx.induced_subgraph(G, comp)
sub = nx.convert_node_labels_to_integers(sub,
label_attribute='old')
yield sub
def apply_subgraphs(algorithm, **params):
cs = []
for sub in connected_subgraphs(G):
if len(sub.nodes) <= 3:
coms = [sub.nodes] # let it be a cluster
else:
coms = algorithm(sub, **params)
if hasattr(coms, 'communities'):
coms = coms.communities
for com in coms:
cs.append([sub.nodes[i]['old'] for i in set(com)])
return cs
def karate_apply(algorithm, graph, **params):
model = algorithm(**params)
model.fit(graph)
return membership2cs(model.get_memberships().values())
if alg == 'big_clam':
c = -1 if params['c'] == 'auto' else int(params['c'])
cs = BigClam('../../snap').run(edges, c=c, xc=int(params['xc']))
elif alg in ('gmm', 'kclique', 'lprop', 'lprop_async', 'fluid',
'girvan_newman', 'angel', 'congo', 'danmf', 'egonet_splitter',
'lfm', 'multicom', 'nmnf', 'nnsed', 'node_perception', 'slpa',
'GEMSEC', 'EdMot', 'demon'):
G = nx.Graph()
G.add_edges_from(edges)
if alg == 'gmm':
cs = community.greedy_modularity_communities(G)
elif alg == 'kclique':
params = {k: float(v) for k, v in params.items()}
cs = community.k_clique_communities(G, **params)
elif alg == 'lprop':
cs = community.label_propagation_communities(G)
elif alg == 'lprop_async':
cs = community.asyn_lpa_communities(G, seed=0)
elif alg == 'fluid':
params = {k: int(v) for k, v in params.items()}
params['seed'] = 0
cs = apply_subgraphs(community.asyn_fluidc, **params)
elif alg == 'girvan_newman':
comp = community.girvan_newman(G)
for cs in itertools.islice(comp, int(params['k'])):
pass
elif alg == 'angel':
params = {k: float(v) for k, v in params.items()}
cs = cdlib.angel(G, **params).communities
elif alg == 'congo': # too slow
ncoms = int(params['number_communities'])
cs = []
for sub in connected_subgraphs(G):
if len(sub.nodes) <= max(3, ncoms):
cs.append(sub.nodes) # let it be a cluster
else:
coms = cdlib.congo(sub,
number_communities=ncoms,
height=int(params['height']))
for com in coms.communities:
cs.append([sub.nodes[i]['old'] for i in set(com)])
elif alg == 'danmf': # no overlapping
cs = apply_subgraphs(cdlib.danmf)
elif alg == 'egonet_splitter':
params['resolution'] = float(params['resolution'])
cs = apply_subgraphs(cdlib.egonet_splitter, **params)
elif alg == 'lfm':
coms = cdlib.lfm(G, float(params['alpha']))
cs = coms.communities
elif alg == 'multicom':
cs = cdlib.multicom(G, seed_node=0).communities
elif alg == 'nmnf':
params = {k: int(v) for k, v in params.items()}
cs = apply_subgraphs(cdlib.nmnf, **params)
elif alg == 'nnsed':
cs = apply_subgraphs(cdlib.nnsed)
elif alg == 'node_perception': # not usable
params = {k: float(v) for k, v in params.items()}
cs = cdlib.node_perception(G, **params).communities
elif alg == 'slpa':
params["t"] = int(params["t"])
params["r"] = float(params["r"])
cs = cdlib.slpa(G, **params).communities
elif alg == 'demon':
params = {k: float(v) for k, v in params.items()}
cs = cdlib.demon(G, **params).communities
elif alg == 'GEMSEC':
# gamma = float(params.pop('gamma'))
params = {k: int(v) for k, v in params.items()}
# params['gamma'] = gamma
params['seed'] = 0
_wrap = partial(karate_apply, karateclub.GEMSEC)
cs = apply_subgraphs(_wrap, **params)
elif alg == 'EdMot':
params = {k: int(v) for k, v in params.items()}
_wrap = partial(karate_apply, karateclub.EdMot)
cs = apply_subgraphs(_wrap, **params)
elif alg in ('infomap', 'community_leading_eigenvector', 'leig',
'multilevel', 'optmod', 'edge_betweenness', 'spinglass',
'walktrap', 'leiden', 'hlc'):
G = igraph.Graph()
G.add_vertices(nnodes)
G.add_edges(edges)
if alg == 'infomap':
vcl = G.community_infomap(trials=int(params['trials']))
cs = membership2cs(vcl.membership)
elif alg == 'leig':
clusters = None if params['clusters'] == 'auto' else int(
params['clusters'])
vcl = G.community_leading_eigenvector(clusters=clusters)
cs = membership2cs(vcl.membership)
elif alg == 'multilevel':
vcl = G.community_multilevel()
cs = membership2cs(vcl.membership)
elif alg == 'optmod': # too long
membership, modularity = G.community_optimal_modularity()
cs = membership2cs(vcl.membership)
elif alg == 'edge_betweenness':
clusters = None if params['clusters'] == 'auto' else int(
params['clusters'])
dendrogram = G.community_edge_betweenness(clusters, directed=False)
try:
clusters = dendrogram.as_clustering()
except:
return []
cs = membership2cs(clusters.membership)
elif alg == 'spinglass': # only for connected graph
vcl = G.community_spinglass(parupdate=True,
update_rule=params['update_rule'],
start_temp=float(params['start_temp']),
stop_temp=float(params['stop_temp']))
cs = membership2cs(vcl.membership)
elif alg == 'walktrap':
dendrogram = G.community_walktrap(steps=int(params['steps']))
try:
clusters = dendrogram.as_clustering()
except:
return []
cs = membership2cs(clusters.membership)
elif alg == 'leiden':
vcl = G.community_leiden(
objective_function=params['objective_function'],
resolution_parameter=float(params['resolution_parameter']),
n_iterations=int(params['n_iterations']))
cs = membership2cs(vcl.membership)
elif alg == 'hlc':
algorithm = HLC(G, min_size=int(params['min_size']))
cs = algorithm.run(None)
elif alg in ("sbm", "sbm_nested"):
np.random.seed(42)
gt.seed_rng(42)
G = gt.Graph(directed=False)
G.add_edge_list(edges)
deg_corr = bool(params['deg_corr'])
B_min = None if params['B_min'] == 'auto' else int(params['B_min'])
B_max = None if params['B_max'] == 'auto' else int(params['B_max'])
if alg == "sbm":
state = gt.minimize_blockmodel_dl(G,
deg_corr=deg_corr,
B_min=B_min,
B_max=B_max)
membership = state.get_blocks()
cs = membership2cs(membership)
if alg == "sbm_nested":
state = gt.minimize_nested_blockmodel_dl(G,
deg_corr=deg_corr,
B_min=B_min,
B_max=B_max)
levels = state.get_bs()
level_max = int(params['level'])
membership = {}
for nid in range(nnodes):
cid = nid
level_i = len(levels)
for level in levels:
cid = level[cid]
if level_i == level_max:
membership.setdefault(cid, []).append(nid)
break
level_i -= 1
cs = membership.values()
else:
return None
return list(cs)
from networkx.algorithms.community.quality import performance
from networkx.algorithms.community.centrality import girvan_newman
# Graph=nx.karate_club_graph()
# Graph=nx.read_gml('datasets/dolphins.gml',label='id')
Graph = nx.fast_gnp_random_graph(25, 0.7)
# Graph=nx.windmill_graph(8,4)
# sizes = [5, 5, 10]
# probs = [[0.05, 0.05, 0.02],
# [0.05, 0.15, 0.07],
# [0.02, 0.07, 0.04]]
# Graph = nx.stochastic_block_model(sizes, probs, seed=0)
gmc = list(greedy_modularity_communities(Graph))
alc = list(asyn_lpa_communities(Graph))
lpac = list(label_propagation_communities(Graph))
asfl = list(asyn_fluidc(Graph, 3))
girvanNewmanCommunities = list(girvan_newman(Graph))
W2 = np.zeros((len(Graph), len(Graph)))
for i in Graph:
for j in nx.neighbors(Graph, i):
W2[i][j] = 1
W2[j][i] = 1
for i in range(len(Graph)):
print(i, end="->")
for j in range(len(Graph)):
if (W2[i][j] == 1):
print(j, end=" ")
print()
W = W2