def node_perception(g_original, threshold, overlap_threshold, min_comm_size=3):
"""Node perception is based on the idea of joining together small sets of nodes.
The algorithm first identifies sub-communities corresponding to each node’s perception of the network around it.
To perform this step, it considers each node individually, and partition that node’s neighbors into communities using some existing community detection method.
Next, it creates a new network in which every node corresponds to a sub-community, and two nodes are linked if their associated sub-communities overlap by at least some threshold amount.
Finally, the algorithm identifies overlapping communities in this new network, and for every such community, merge together the associated sub-communities to identify communities in the original network.
:param g_original: a networkx/igraph object
:param threshold: the tolerance required in order to merge communities
:param overlap_threshold: the overlap tolerance
:param min_comm_size: minimum community size default 3
:return: NodeClustering object
:Example:
>>> from cdlib import algorithms
>>> import networkx as nx
>>> G = nx.karate_club_graph()
>>> coms = algorithms.node_perception(G, threshold=0.25, overlap_threshold=0.25)
:References:
Sucheta Soundarajan and John E. Hopcroft. 2015. `Use of Local Group Information to Identify Communities in Networks. <https://dl.acm.org/citation.cfm?id=2737800.2700404/>`_ ACM Trans. Knowl. Discov. Data 9, 3, Article 21 (April 2015), 27 pages. DOI=http://dx.doi.org/10.1145/2700404
"""
g = convert_graph_formats(g_original, nx.Graph)
tp = type(list(g.nodes())[0])
with suppress_stdout():
np = NodePerception(g,
sim_threshold=threshold,
overlap_threshold=overlap_threshold,
min_comm_size=min_comm_size)
coms = np.execute()
if tp != str:
communities = []
for c in coms:
c = list(map(tp, c))
communities.append(c)
coms = communities
return NodeClustering(coms,
g_original,
"Node Perception",
method_parameters={
"threshold": threshold,
"overlap_threshold": overlap_threshold,
"min_com_size": min_comm_size
},
overlap=True)
def angel(g_original, threshold, min_community_size=3):
"""
Angel is a node-centric bottom-up community discovery algorithm.
It leverages ego-network structures and overlapping label propagation to identify micro-scale communities that are subsequently merged in mesoscale ones.
Angel is the, faster, successor of Demon.
:param g_original: a networkx/igraph object
:param threshold: merging threshold in [0,1].
:param min_community_size: minimum community size, default 3.
:return: NodeClustering object
:Example:
>>> from cdlib import algorithms
>>> import networkx as nx
>>> G = nx.karate_club_graph()
>>> coms = algorithms.angel(G, min_com_size=3, threshold=0.25)
:References:
1. Rossetti, Giulio. "Exorcising the Demon: Angel, Efficient Node-Centric Community Discovery." International Conference on Complex Networks and Their Applications. Springer, Cham, 2019.
.. note:: Reference implementation: https://github.com/GiulioRossetti/ANGEL
"""
if ig is None:
raise ModuleNotFoundError(
"Optional dependency not satisfied: install igraph to use the selected feature."
)
if Angel is None:
raise ModuleNotFoundError(
"Optional dependency not satisfied: install angel-cd library to use the selected feature (likely pip install angel-cd). If using a notebook, you need also to restart your runtime/kernel."
)
g = convert_graph_formats(g_original, ig.Graph)
with suppress_stdout():
a = Angel(graph=g,
min_comsize=min_community_size,
threshold=threshold,
save=False)
coms = a.execute()
return NodeClustering(list(coms.values()),
g_original,
"ANGEL",
method_parameters={
"threshold": threshold,
"min_community_size": min_community_size
},
overlap=True)
def angel(g, threshold, min_community_size=3):
"""
Angel is a node-centric bottom-up community discovery algorithm.
It leverages ego-network structures and overlapping label propagation to identify micro-scale communities that are subsequently merged in mesoscale ones.
Angel is the, faster, successor of Demon.
:param g: a networkx/igraph object
:param threshold: merging threshold in [0,1].
:param min_community_size: minimum community size, default 3.
:return: NodeClustering object
:Example:
>>> from cdlib import algorithms
>>> import networkx as nx
>>> G = nx.karate_club_graph()
>>> coms = algorithms.angel(G, min_com_size=3, threshold=0.25)
:References:
1. Rossetti G. **Angel: efficient, and effective, node-centric community discovery in static and dynamic networks.**
.. note:: Reference implementation: https://github.com/GiulioRossetti/ANGEL
"""
if ig is None:
raise ModuleNotFoundError(
"Optional dependency not satisfied: install igraph to use the selected feature."
)
g = convert_graph_formats(g, ig.Graph)
with suppress_stdout():
a = Angel(graph=g,
min_comsize=min_community_size,
threshold=threshold,
save=False)
coms = a.execute()
return NodeClustering(list(coms.values()),
g,
"ANGEL",
method_parameters={
"threshold": threshold,
"min_community_size": min_community_size
},
overlap=True)
def demon(g_original, epsilon, min_com_size=3):
"""
Demon is a node-centric bottom-up overlapping community discovery algorithm.
It leverages ego-network structures and overlapping label propagation to identify micro-scale communities that are subsequently merged in mesoscale ones.
:param g_original: a networkx/igraph object
:param epsilon: merging threshold in [0,1], default 0.25.
:param min_com_size: minimum community size, default 3.
:return: NodeClustering object
:Example:
>>> from cdlib import algorithms
>>> import networkx as nx
>>> G = nx.karate_club_graph()
>>> coms = algorithms.demon(G, min_com_size=3, epsilon=0.25)
:References:
1. Coscia, M., Rossetti, G., Giannotti, F., & Pedreschi, D. (2012, August). `Demon: a local-first discovery method for overlapping communities. <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.721.1788&rep=rep1&type=pdf/>`_ In Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 615-623). ACM.
2. Coscia, M., Rossetti, G., Giannotti, F., & Pedreschi, D. (2014). `Uncovering hierarchical and overlapping communities with a local-first approach. <https://dl.acm.org/citation.cfm?id=2629511/>`_ ACM Transactions on Knowledge Discovery from Data (TKDD), 9(1), 6.
.. note:: Reference implementation: https://github.com/GiulioRossetti/DEMON
"""
g = convert_graph_formats(g_original, nx.Graph)
with suppress_stdout():
dm = Demon(graph=g, epsilon=epsilon, min_community_size=min_com_size)
coms = dm.execute()
coms = [list(c) for c in coms]
return NodeClustering(coms,
g_original,
"DEMON",
method_parameters={
"epsilon": epsilon,
"min_com_size": min_com_size
},
overlap=True)
