def test_read_write_json(self):
g = nx.karate_club_graph()
communities = algorithms.louvain(g)
readwrite.write_community_json(communities, "coms.json")
communities_r = readwrite.read_community_json("coms.json")
self.assertListEqual(communities.communities,
communities_r.communities)
os.remove("coms.json")
communities = algorithms.louvain(g)
readwrite.write_community_json(communities, "coms.gzip", zip=True)
communities_r = readwrite.read_community_json("coms.gzip", zip=True)
self.assertListEqual(communities.communities,
communities_r.communities)
os.remove("coms.gzip")
communities = algorithms.frc_fgsn(g, 1, 0.5, 3)
readwrite.write_community_json(communities, "coms.json")
communities_r = readwrite.read_community_json("coms.json")
self.assertListEqual(communities.communities,
communities_r.communities)
os.remove("coms.json")
communities = algorithms.hierarchical_link_community(g)
readwrite.write_community_json(communities, "coms.json")
communities_r = readwrite.read_community_json("coms.json")
self.assertListEqual(communities.communities,
communities_r.communities)
with open("coms.json") as f:
cr = f.read()
readwrite.read_community_from_json_string(cr)
os.remove("coms.json")
def test_pquality_indexes(self):
g = nx.karate_club_graph()
communities = louvain(g)
indexes = [
evaluation.normalized_cut, evaluation.internal_edge_density,
evaluation.average_internal_degree,
evaluation.fraction_over_median_degree, evaluation.expansion,
evaluation.cut_ratio, evaluation.edges_inside,
evaluation.conductance, evaluation.max_odf, evaluation.avg_odf,
evaluation.flake_odf, evaluation.triangle_participation_ratio,
evaluation.size, evaluation.avg_embeddedness,
evaluation.scaled_density, evaluation.avg_distance,
evaluation.hub_dominance, evaluation.avg_transitivity,
evaluation.modularity_overlap
]
for idx in indexes:
res = idx(g, communities)
self.assertIsInstance(res, evaluation.FitnessResult)
for idx in indexes:
try:
res = idx(g, communities, summary=False)
self.assertIsInstance(res, list)
except:
pass
def test_fitness_scores(self):
g = nx.karate_club_graph()
coms = algorithms.louvain(g)
self.assertIsInstance(coms.link_modularity().score, float)
self.assertIsInstance(coms.normalized_cut(), evaluation.FitnessResult)
self.assertIsInstance(coms.size(), evaluation.FitnessResult)
self.assertIsInstance(coms.avg_embeddedness(), evaluation.FitnessResult)
self.assertIsInstance(coms.avg_transitivity(), evaluation.FitnessResult)
self.assertIsInstance(coms.hub_dominance(), evaluation.FitnessResult)
self.assertIsInstance(coms.avg_distance(), evaluation.FitnessResult)
self.assertIsInstance(coms.scaled_density(), evaluation.FitnessResult)
self.assertIsInstance(coms.internal_edge_density(), evaluation.FitnessResult)
self.assertIsInstance(coms.average_internal_degree(), evaluation.FitnessResult)
self.assertIsInstance(
coms.fraction_over_median_degree(), evaluation.FitnessResult
)
self.assertIsInstance(coms.expansion(), evaluation.FitnessResult)
self.assertIsInstance(coms.modularity_overlap(), evaluation.FitnessResult)
self.assertIsInstance(coms.cut_ratio(), evaluation.FitnessResult)
self.assertIsInstance(coms.edges_inside(), evaluation.FitnessResult)
self.assertIsInstance(coms.conductance(), evaluation.FitnessResult)
self.assertIsInstance(coms.max_odf(), evaluation.FitnessResult)
self.assertIsInstance(coms.avg_odf(), evaluation.FitnessResult)
self.assertIsInstance(coms.flake_odf(), evaluation.FitnessResult)
self.assertIsInstance(
coms.triangle_participation_ratio(), evaluation.FitnessResult
)
self.assertIsInstance(coms.newman_girvan_modularity().score, float)
self.assertIsInstance(coms.erdos_renyi_modularity().score, float)
self.assertIsInstance(coms.modularity_density().score, float)
self.assertIsInstance(coms.z_modularity().score, float)
self.assertIsInstance(coms.surprise().score, float)
self.assertIsInstance(coms.significance().score, float)
def test_louvain(self):
g = get_string_graph()
coms = algorithms.louvain(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 densestCommunity(graph):
'''Extracts the densest community of a graph, with Louvain algorithm.
Input:
- graph: weighted graph.
Output:
- graphDC: subgraph induced on the nodes of the densest community of the graph.'''
# Louvain algorithm to extract communities from the graph
NodeClustering = algorithms.louvain(
graph, weight='weight', resolution=1., randomize=False)
# Stores the maximum density found
maxWeight = 0
dcs = [] # Initializes DCS node list
# Iterates the communities, found in the alignment graph
for i in NodeClustering.communities:
# Extracts from graph a subgraph containing the nodes of community i
Sg = graph.subgraph(i)
# # Calculates the density
dWs = densityWgraph(Sg)
# If the actual calculated density is greater than the stored one
if dWs > maxWeight:
# The current density is stored as maximum
maxWeight = dWs
# And the subgraphs found are stored
dcs = i.copy()
# Found the community of graph with maximum density
# Extracts from graph a community
# containing the nodes of the maximum community stored in dcs
graphDC = graph.subgraph(dcs)
print("Densest Community of weighted graph --> nodes: ", len(graphDC.nodes), ", edges: ",
len(graphDC.edges), "; density: ", maxWeight)
# Returns DCS graph
return graphDC
def compute_indexes(G: nx.Graph, method, negative, positive):
if method == 'resource_allocation':
return nx.resource_allocation_index(
G, negative), nx.resource_allocation_index(G, positive)
elif method == 'jaccard_coefficient':
return nx.jaccard_coefficient(G, negative), nx.jaccard_coefficient(
G, positive)
elif method == 'adamic_adar':
return nx.adamic_adar_index(G, negative), nx.adamic_adar_index(
G, positive)
elif method == 'preferential_attachment':
return nx.preferential_attachment(
G, negative), nx.preferential_attachment(G, positive)
elif method == 'sorensen_neighbours':
return ([(u, v, sorensen_index(G, u, v)) for u, v in negative],
[(u, v, sorensen_index(G, u, v)) for u, v in positive])
elif method == 'community':
c = louvain(G)
commLabels = c.communities
comms = c.to_node_community_map()
return ([(u, v, community_index(G, u, v, commLabels, comms))
for u, v in negative],
[(u, v, community_index(G, u, v, commLabels, comms))
for u, v in positive])
else:
raise NameError('The given method is not supported')
def test_surprise(self):
g = nx.karate_club_graph()
communities = louvain(g)
mod = evaluation.surprise(g, communities)
self.assertLessEqual(mod.score, g.number_of_edges())
self.assertGreaterEqual(mod.score, 0)
def test_link_modularity(self):
g = nx.karate_club_graph()
communities = louvain(g)
mod = evaluation.link_modularity(g, communities)
self.assertLessEqual(mod.score, 1)
self.assertGreaterEqual(mod.score, 0)
def test_closeness_simple(self):
g = nx.karate_club_graph()
lp_communities = label_propagation(g)
louvain_communities = louvain(g)
score = evaluation.partition_closeness_simple(louvain_communities, lp_communities)
self.assertLessEqual(score.score, 1)
self.assertGreaterEqual(score.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_read_write(self):
g = nx.karate_club_graph()
communities = algorithms.louvain(g)
readwrite.write_community_csv(communities, "coms.csv")
communities_r = readwrite.read_community_csv("coms.csv", nodetype=int)
self.assertListEqual(communities.communities,
communities_r.communities)
os.remove("coms.csv")
def test_f1(self):
g = nx.karate_club_graph()
lp_communities = label_propagation(g)
louvain_communities = louvain(g)
score = evaluation.f1(louvain_communities, lp_communities)
self.assertIsInstance(score, evaluation.MatchingResult)
def test_adjusted_rand(self):
g = nx.karate_club_graph()
lp_communities = label_propagation(g)
louvain_communities = louvain(g)
score = evaluation.adjusted_rand_index(louvain_communities, lp_communities)
self.assertLessEqual(score.score, 1)
self.assertGreaterEqual(score.score, 0)
def test_variation_of_information(self):
g = nx.karate_club_graph()
lp_communities = label_propagation(g)
louvain_communities = louvain(g)
score = evaluation.variation_of_information(louvain_communities, lp_communities)
self.assertLessEqual(score.score, np.log(g.number_of_nodes()))
self.assertGreaterEqual(score.score, 0)
def get_temporal_network_clustering():
tc = TemporalClustering()
for t in range(10):
g = nx.erdos_renyi_graph(100, 0.05)
coms = algorithms.louvain(g)
tc.add_clustering(coms, t)
return tc
def test_remap_node_community(self):
g = get_string_graph()
nodes = list(g.nodes())
g, node_map = utils.nx_node_integer_mapping(g)
coms = algorithms.louvain(g)
coms_remap = utils.remap_node_communities(coms.communities, node_map)
flat_list = [item for sublist in coms_remap for item in sublist]
self.assertListEqual(sorted(nodes), sorted(flat_list))
def test_nmi(self):
g = nx.karate_club_graph()
louvain_communities = louvain(g)
lp_communities = label_propagation(g)
score = evaluation.normalized_mutual_information(louvain_communities, lp_communities)
self.assertLessEqual(score.score, 1)
self.assertGreaterEqual(score.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_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 extractLouvain(W):
try:
print("Start Modularity")
coms = algorithms.louvain(W, weight='weight', resolution=1., randomize=False)
except Exception as inst:
print(type(inst)) # the exception instance
print(inst.args) # arguments stored in .args
print(inst)
return -1
return coms
def test_plot_sim_matrix(self):
g = nx.karate_club_graph()
coms = algorithms.louvain(g)
coms2 = algorithms.label_propagation(g)
viz.plot_sim_matrix([coms, coms2],
evaluation.adjusted_mutual_information)
plt.savefig("cluster.pdf")
os.remove("cluster.pdf")
def test_to_json(self):
g = nx.karate_club_graph()
coms = algorithms.louvain(g)
self.assertIsInstance(coms, NodeClustering)
js = coms.to_json()
self.assertIsInstance(js, str)
self.assertEqual(coms.node_coverage, 1.0)
coms = algorithms.frc_fgsn(g, 0.5, 0.3, 1)
js = coms.to_json()
self.assertIsInstance(js, str)
def get_temporal_network_clustering():
tc = TemporalClustering()
for t in range(10):
g = nx.erdos_renyi_graph(100, 0.05)
coms = algorithms.louvain(g)
# simulating named clustering
nc = NamedClustering({i: c for i, c in enumerate(coms.communities)}, g, coms.method_name)
tc.add_clustering(nc, t)
return tc
def test_pquality_indexes(self):
g = nx.karate_club_graph()
communities = louvain(g)
indexes = [evaluation.normalized_cut, evaluation.internal_edge_density, evaluation.average_internal_degree,
evaluation.fraction_over_median_degree, evaluation.expansion, evaluation.cut_ratio,
evaluation.edges_inside, evaluation.conductance, evaluation.max_odf, evaluation.avg_odf,
evaluation.flake_odf, evaluation.triangle_participation_ratio, evaluation.size]
for idx in indexes:
res = idx(g, communities)
self.assertIsInstance(res, evaluation.FitnessResult)
def test_endntm(self):
G = nx.karate_club_graph()
coms_l = [
algorithms.louvain(G),
algorithms.label_propagation(G),
algorithms.walktrap(G),
]
coms = algorithms.endntm(G, coms_l)
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]), int)
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)
def test_community_graph(self):
g = nx.karate_club_graph()
coms = algorithms.louvain(g)
viz.plot_community_graph(g, coms)
plt.savefig("cg.pdf")
os.remove("cg.pdf")
coms = algorithms.angel(g, 0.25)
viz.plot_community_graph(g, coms, plot_overlaps=True, plot_labels=True)
plt.savefig("cg.pdf")
os.remove("cg.pdf")
def test_plot_com_stat(self):
g = nx.karate_club_graph()
coms = algorithms.louvain(g)
coms2 = algorithms.label_propagation(g)
viz.plot_com_stat([coms, coms2], evaluation.size)
plt.savefig("cluster.pdf")
os.remove("cluster.pdf")
viz.plot_com_stat(coms, evaluation.size)
plt.savefig("cluster.pdf")
os.remove("cluster.pdf")
def community_vaccination(self, A, param=[8, 0.5]):
# Use an algo to detect communities.
communities = algo.louvain(nx.Graph(A)).communities
# Get the nodes with highest "out_community" links.
opt1 = target_nodes(communities, param[0], out_community=True)[0]
opt2 = self.select_nodes(A, state=0, nei_thres=0)
opt = np.intersect1d(opt1, opt2)
idx = np.random.choice(opt, ceil(len(opt) * param[1]), replace=False)
A[idx, :] = 0
A[:, idx] = 0
self.initialize_nodes(idx, state=0)
self.vacci_num = len(idx)
return A
def smart_walk(chord_graph,
start_chord=None,
progression_length=4,
out_threshold=0.85):
communities = algorithms.louvain(chord_graph.to_undirected())
chord_path = []
visited_chords = []
current_chord = start_chord
if current_chord == None:
pagerank = np.array(
list(nx.get_node_attributes(
chord_graph,
"pagerank",
).values()))
pagerank = np.array(pagerank) / sum(
pagerank) # normalizing pagerank values to get probability distr.
current_chord = np.random.choice(a=list(chord_graph.nodes), p=pagerank)
for chord_step in range(progression_length):
chord_path.append(current_chord)
visited_chords.append(current_chord)
neighboring_chords = list(chord_graph.neighbors(current_chord))
probabilities = []
possible_next_chords = []
rand = np.random.uniform(0, 1)
if rand < out_threshold:
community_index = [
True if current_chord in community else False
for community in communities.communities
].index(True)
possible_next_chords = [
chord for chord in neighboring_chords
if chord in communities.communities[community_index]
]
if len(possible_next_chords) == 0:
possible_next_chords = neighboring_chords
else:
possible_next_chords = neighboring_chords + visited_chords
for chord in possible_next_chords:
probabilities.append(
int(chord_graph.in_degree(chord, weight='weight')))
probabilities = np.array(probabilities) / sum(probabilities)
current_chord = np.random.choice(possible_next_chords, p=probabilities)
return chord_path
