1062 lines
34 KiB
Python
1062 lines
34 KiB
Python
"""Generators for classes of graphs used in studying social networks."""
|
|
import itertools
|
|
import math
|
|
import networkx as nx
|
|
from networkx.utils import py_random_state
|
|
|
|
|
|
__all__ = [
|
|
"caveman_graph",
|
|
"connected_caveman_graph",
|
|
"relaxed_caveman_graph",
|
|
"random_partition_graph",
|
|
"planted_partition_graph",
|
|
"gaussian_random_partition_graph",
|
|
"ring_of_cliques",
|
|
"windmill_graph",
|
|
"stochastic_block_model",
|
|
"LFR_benchmark_graph",
|
|
]
|
|
|
|
|
|
def caveman_graph(l, k):
|
|
"""Returns a caveman graph of `l` cliques of size `k`.
|
|
|
|
Parameters
|
|
----------
|
|
l : int
|
|
Number of cliques
|
|
k : int
|
|
Size of cliques
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph
|
|
caveman graph
|
|
|
|
Notes
|
|
-----
|
|
This returns an undirected graph, it can be converted to a directed
|
|
graph using :func:`nx.to_directed`, or a multigraph using
|
|
``nx.MultiGraph(nx.caveman_graph(l, k))``. Only the undirected version is
|
|
described in [1]_ and it is unclear which of the directed
|
|
generalizations is most useful.
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.caveman_graph(3, 3)
|
|
|
|
See also
|
|
--------
|
|
|
|
connected_caveman_graph
|
|
|
|
References
|
|
----------
|
|
.. [1] Watts, D. J. 'Networks, Dynamics, and the Small-World Phenomenon.'
|
|
Amer. J. Soc. 105, 493-527, 1999.
|
|
"""
|
|
# l disjoint cliques of size k
|
|
G = nx.empty_graph(l * k)
|
|
if k > 1:
|
|
for start in range(0, l * k, k):
|
|
edges = itertools.combinations(range(start, start + k), 2)
|
|
G.add_edges_from(edges)
|
|
return G
|
|
|
|
|
|
def connected_caveman_graph(l, k):
|
|
"""Returns a connected caveman graph of `l` cliques of size `k`.
|
|
|
|
The connected caveman graph is formed by creating `n` cliques of size
|
|
`k`, then a single edge in each clique is rewired to a node in an
|
|
adjacent clique.
|
|
|
|
Parameters
|
|
----------
|
|
l : int
|
|
number of cliques
|
|
k : int
|
|
size of cliques (k at least 2 or NetworkXError is raised)
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph
|
|
connected caveman graph
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If the size of cliques `k` is smaller than 2.
|
|
|
|
Notes
|
|
-----
|
|
This returns an undirected graph, it can be converted to a directed
|
|
graph using :func:`nx.to_directed`, or a multigraph using
|
|
``nx.MultiGraph(nx.caveman_graph(l, k))``. Only the undirected version is
|
|
described in [1]_ and it is unclear which of the directed
|
|
generalizations is most useful.
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.connected_caveman_graph(3, 3)
|
|
|
|
References
|
|
----------
|
|
.. [1] Watts, D. J. 'Networks, Dynamics, and the Small-World Phenomenon.'
|
|
Amer. J. Soc. 105, 493-527, 1999.
|
|
"""
|
|
if k < 2:
|
|
raise nx.NetworkXError(
|
|
"The size of cliques in a connected caveman graph " "must be at least 2."
|
|
)
|
|
|
|
G = nx.caveman_graph(l, k)
|
|
for start in range(0, l * k, k):
|
|
G.remove_edge(start, start + 1)
|
|
G.add_edge(start, (start - 1) % (l * k))
|
|
return G
|
|
|
|
|
|
@py_random_state(3)
|
|
def relaxed_caveman_graph(l, k, p, seed=None):
|
|
"""Returns a relaxed caveman graph.
|
|
|
|
A relaxed caveman graph starts with `l` cliques of size `k`. Edges are
|
|
then randomly rewired with probability `p` to link different cliques.
|
|
|
|
Parameters
|
|
----------
|
|
l : int
|
|
Number of groups
|
|
k : int
|
|
Size of cliques
|
|
p : float
|
|
Probabilty of rewiring each edge.
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph
|
|
Relaxed Caveman Graph
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If p is not in [0,1]
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.relaxed_caveman_graph(2, 3, 0.1, seed=42)
|
|
|
|
References
|
|
----------
|
|
.. [1] Santo Fortunato, Community Detection in Graphs,
|
|
Physics Reports Volume 486, Issues 3-5, February 2010, Pages 75-174.
|
|
https://arxiv.org/abs/0906.0612
|
|
"""
|
|
G = nx.caveman_graph(l, k)
|
|
nodes = list(G)
|
|
for (u, v) in G.edges():
|
|
if seed.random() < p: # rewire the edge
|
|
x = seed.choice(nodes)
|
|
if G.has_edge(u, x):
|
|
continue
|
|
G.remove_edge(u, v)
|
|
G.add_edge(u, x)
|
|
return G
|
|
|
|
|
|
@py_random_state(3)
|
|
def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
|
|
"""Returns the random partition graph with a partition of sizes.
|
|
|
|
A partition graph is a graph of communities with sizes defined by
|
|
s in sizes. Nodes in the same group are connected with probability
|
|
p_in and nodes of different groups are connected with probability
|
|
p_out.
|
|
|
|
Parameters
|
|
----------
|
|
sizes : list of ints
|
|
Sizes of groups
|
|
p_in : float
|
|
probability of edges with in groups
|
|
p_out : float
|
|
probability of edges between groups
|
|
directed : boolean optional, default=False
|
|
Whether to create a directed graph
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph or DiGraph
|
|
random partition graph of size sum(gs)
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If p_in or p_out is not in [0,1]
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.random_partition_graph([10, 10, 10], 0.25, 0.01)
|
|
>>> len(G)
|
|
30
|
|
>>> partition = G.graph["partition"]
|
|
>>> len(partition)
|
|
3
|
|
|
|
Notes
|
|
-----
|
|
This is a generalization of the planted-l-partition described in
|
|
[1]_. It allows for the creation of groups of any size.
|
|
|
|
The partition is store as a graph attribute 'partition'.
|
|
|
|
References
|
|
----------
|
|
.. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
|
|
Volume 486, Issue 3-5 p. 75-174. https://arxiv.org/abs/0906.0612
|
|
"""
|
|
# Use geometric method for O(n+m) complexity algorithm
|
|
# partition = nx.community_sets(nx.get_node_attributes(G, 'affiliation'))
|
|
if not 0.0 <= p_in <= 1.0:
|
|
raise nx.NetworkXError("p_in must be in [0,1]")
|
|
if not 0.0 <= p_out <= 1.0:
|
|
raise nx.NetworkXError("p_out must be in [0,1]")
|
|
|
|
# create connection matrix
|
|
num_blocks = len(sizes)
|
|
p = [[p_out for s in range(num_blocks)] for r in range(num_blocks)]
|
|
for r in range(num_blocks):
|
|
p[r][r] = p_in
|
|
|
|
return stochastic_block_model(
|
|
sizes,
|
|
p,
|
|
nodelist=None,
|
|
seed=seed,
|
|
directed=directed,
|
|
selfloops=False,
|
|
sparse=True,
|
|
)
|
|
|
|
|
|
@py_random_state(4)
|
|
def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
|
|
"""Returns the planted l-partition graph.
|
|
|
|
This model partitions a graph with n=l*k vertices in
|
|
l groups with k vertices each. Vertices of the same
|
|
group are linked with a probability p_in, and vertices
|
|
of different groups are linked with probability p_out.
|
|
|
|
Parameters
|
|
----------
|
|
l : int
|
|
Number of groups
|
|
k : int
|
|
Number of vertices in each group
|
|
p_in : float
|
|
probability of connecting vertices within a group
|
|
p_out : float
|
|
probability of connected vertices between groups
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
directed : bool,optional (default=False)
|
|
If True return a directed graph
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph or DiGraph
|
|
planted l-partition graph
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If p_in,p_out are not in [0,1] or
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.planted_partition_graph(4, 3, 0.5, 0.1, seed=42)
|
|
|
|
See Also
|
|
--------
|
|
random_partition_model
|
|
|
|
References
|
|
----------
|
|
.. [1] A. Condon, R.M. Karp, Algorithms for graph partitioning
|
|
on the planted partition model,
|
|
Random Struct. Algor. 18 (2001) 116-140.
|
|
|
|
.. [2] Santo Fortunato 'Community Detection in Graphs' Physical Reports
|
|
Volume 486, Issue 3-5 p. 75-174. https://arxiv.org/abs/0906.0612
|
|
"""
|
|
return random_partition_graph([k] * l, p_in, p_out, seed=seed, directed=directed)
|
|
|
|
|
|
@py_random_state(6)
|
|
def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=None):
|
|
"""Generate a Gaussian random partition graph.
|
|
|
|
A Gaussian random partition graph is created by creating k partitions
|
|
each with a size drawn from a normal distribution with mean s and variance
|
|
s/v. Nodes are connected within clusters with probability p_in and
|
|
between clusters with probability p_out[1]
|
|
|
|
Parameters
|
|
----------
|
|
n : int
|
|
Number of nodes in the graph
|
|
s : float
|
|
Mean cluster size
|
|
v : float
|
|
Shape parameter. The variance of cluster size distribution is s/v.
|
|
p_in : float
|
|
Probabilty of intra cluster connection.
|
|
p_out : float
|
|
Probability of inter cluster connection.
|
|
directed : boolean, optional default=False
|
|
Whether to create a directed graph or not
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph or DiGraph
|
|
gaussian random partition graph
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If s is > n
|
|
If p_in or p_out is not in [0,1]
|
|
|
|
Notes
|
|
-----
|
|
Note the number of partitions is dependent on s,v and n, and that the
|
|
last partition may be considerably smaller, as it is sized to simply
|
|
fill out the nodes [1]
|
|
|
|
See Also
|
|
--------
|
|
random_partition_graph
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.gaussian_random_partition_graph(100, 10, 10, 0.25, 0.1)
|
|
>>> len(G)
|
|
100
|
|
|
|
References
|
|
----------
|
|
.. [1] Ulrik Brandes, Marco Gaertler, Dorothea Wagner,
|
|
Experiments on Graph Clustering Algorithms,
|
|
In the proceedings of the 11th Europ. Symp. Algorithms, 2003.
|
|
"""
|
|
if s > n:
|
|
raise nx.NetworkXError("s must be <= n")
|
|
assigned = 0
|
|
sizes = []
|
|
while True:
|
|
size = int(seed.gauss(s, float(s) / v + 0.5))
|
|
if size < 1: # how to handle 0 or negative sizes?
|
|
continue
|
|
if assigned + size >= n:
|
|
sizes.append(n - assigned)
|
|
break
|
|
assigned += size
|
|
sizes.append(size)
|
|
return random_partition_graph(sizes, p_in, p_out, seed=seed, directed=directed)
|
|
|
|
|
|
def ring_of_cliques(num_cliques, clique_size):
|
|
"""Defines a "ring of cliques" graph.
|
|
|
|
A ring of cliques graph is consisting of cliques, connected through single
|
|
links. Each clique is a complete graph.
|
|
|
|
Parameters
|
|
----------
|
|
num_cliques : int
|
|
Number of cliques
|
|
clique_size : int
|
|
Size of cliques
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph
|
|
ring of cliques graph
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If the number of cliques is lower than 2 or
|
|
if the size of cliques is smaller than 2.
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.ring_of_cliques(8, 4)
|
|
|
|
See Also
|
|
--------
|
|
connected_caveman_graph
|
|
|
|
Notes
|
|
-----
|
|
The `connected_caveman_graph` graph removes a link from each clique to
|
|
connect it with the next clique. Instead, the `ring_of_cliques` graph
|
|
simply adds the link without removing any link from the cliques.
|
|
"""
|
|
if num_cliques < 2:
|
|
raise nx.NetworkXError("A ring of cliques must have at least " "two cliques")
|
|
if clique_size < 2:
|
|
raise nx.NetworkXError("The cliques must have at least two nodes")
|
|
|
|
G = nx.Graph()
|
|
for i in range(num_cliques):
|
|
edges = itertools.combinations(
|
|
range(i * clique_size, i * clique_size + clique_size), 2
|
|
)
|
|
G.add_edges_from(edges)
|
|
G.add_edge(
|
|
i * clique_size + 1, (i + 1) * clique_size % (num_cliques * clique_size)
|
|
)
|
|
return G
|
|
|
|
|
|
def windmill_graph(n, k):
|
|
"""Generate a windmill graph.
|
|
A windmill graph is a graph of `n` cliques each of size `k` that are all
|
|
joined at one node.
|
|
It can be thought of as taking a disjoint union of `n` cliques of size `k`,
|
|
selecting one point from each, and contracting all of the selected points.
|
|
Alternatively, one could generate `n` cliques of size `k-1` and one node
|
|
that is connected to all other nodes in the graph.
|
|
|
|
Parameters
|
|
----------
|
|
n : int
|
|
Number of cliques
|
|
k : int
|
|
Size of cliques
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX Graph
|
|
windmill graph with n cliques of size k
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If the number of cliques is less than two
|
|
If the size of the cliques are less than two
|
|
|
|
Examples
|
|
--------
|
|
>>> G = nx.windmill_graph(4, 5)
|
|
|
|
Notes
|
|
-----
|
|
The node labeled `0` will be the node connected to all other nodes.
|
|
Note that windmill graphs are usually denoted `Wd(k,n)`, so the parameters
|
|
are in the opposite order as the parameters of this method.
|
|
"""
|
|
if n < 2:
|
|
msg = "A windmill graph must have at least two cliques"
|
|
raise nx.NetworkXError(msg)
|
|
if k < 2:
|
|
raise nx.NetworkXError("The cliques must have at least two nodes")
|
|
|
|
G = nx.disjoint_union_all(
|
|
itertools.chain(
|
|
[nx.complete_graph(k)], (nx.complete_graph(k - 1) for _ in range(n - 1))
|
|
)
|
|
)
|
|
G.add_edges_from((0, i) for i in range(k, G.number_of_nodes()))
|
|
return G
|
|
|
|
|
|
@py_random_state(3)
|
|
def stochastic_block_model(
|
|
sizes, p, nodelist=None, seed=None, directed=False, selfloops=False, sparse=True
|
|
):
|
|
"""Returns a stochastic block model graph.
|
|
|
|
This model partitions the nodes in blocks of arbitrary sizes, and places
|
|
edges between pairs of nodes independently, with a probability that depends
|
|
on the blocks.
|
|
|
|
Parameters
|
|
----------
|
|
sizes : list of ints
|
|
Sizes of blocks
|
|
p : list of list of floats
|
|
Element (r,s) gives the density of edges going from the nodes
|
|
of group r to nodes of group s.
|
|
p must match the number of groups (len(sizes) == len(p)),
|
|
and it must be symmetric if the graph is undirected.
|
|
nodelist : list, optional
|
|
The block tags are assigned according to the node identifiers
|
|
in nodelist. If nodelist is None, then the ordering is the
|
|
range [0,sum(sizes)-1].
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
directed : boolean optional, default=False
|
|
Whether to create a directed graph or not.
|
|
selfloops : boolean optional, default=False
|
|
Whether to include self-loops or not.
|
|
sparse: boolean optional, default=True
|
|
Use the sparse heuristic to speed up the generator.
|
|
|
|
Returns
|
|
-------
|
|
g : NetworkX Graph or DiGraph
|
|
Stochastic block model graph of size sum(sizes)
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If probabilities are not in [0,1].
|
|
If the probability matrix is not square (directed case).
|
|
If the probability matrix is not symmetric (undirected case).
|
|
If the sizes list does not match nodelist or the probability matrix.
|
|
If nodelist contains duplicate.
|
|
|
|
Examples
|
|
--------
|
|
>>> sizes = [75, 75, 300]
|
|
>>> probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
|
|
>>> g = nx.stochastic_block_model(sizes, probs, seed=0)
|
|
>>> len(g)
|
|
450
|
|
>>> H = nx.quotient_graph(g, g.graph["partition"], relabel=True)
|
|
>>> for v in H.nodes(data=True):
|
|
... print(round(v[1]["density"], 3))
|
|
...
|
|
0.245
|
|
0.348
|
|
0.405
|
|
>>> for v in H.edges(data=True):
|
|
... print(round(1.0 * v[2]["weight"] / (sizes[v[0]] * sizes[v[1]]), 3))
|
|
...
|
|
0.051
|
|
0.022
|
|
0.07
|
|
|
|
See Also
|
|
--------
|
|
random_partition_graph
|
|
planted_partition_graph
|
|
gaussian_random_partition_graph
|
|
gnp_random_graph
|
|
|
|
References
|
|
----------
|
|
.. [1] Holland, P. W., Laskey, K. B., & Leinhardt, S.,
|
|
"Stochastic blockmodels: First steps",
|
|
Social networks, 5(2), 109-137, 1983.
|
|
"""
|
|
# Check if dimensions match
|
|
if len(sizes) != len(p):
|
|
raise nx.NetworkXException("'sizes' and 'p' do not match.")
|
|
# Check for probability symmetry (undirected) and shape (directed)
|
|
for row in p:
|
|
if len(p) != len(row):
|
|
raise nx.NetworkXException("'p' must be a square matrix.")
|
|
if not directed:
|
|
p_transpose = [list(i) for i in zip(*p)]
|
|
for i in zip(p, p_transpose):
|
|
for j in zip(i[0], i[1]):
|
|
if abs(j[0] - j[1]) > 1e-08:
|
|
raise nx.NetworkXException("'p' must be symmetric.")
|
|
# Check for probability range
|
|
for row in p:
|
|
for prob in row:
|
|
if prob < 0 or prob > 1:
|
|
raise nx.NetworkXException("Entries of 'p' not in [0,1].")
|
|
# Check for nodelist consistency
|
|
if nodelist is not None:
|
|
if len(nodelist) != sum(sizes):
|
|
raise nx.NetworkXException("'nodelist' and 'sizes' do not match.")
|
|
if len(nodelist) != len(set(nodelist)):
|
|
raise nx.NetworkXException("nodelist contains duplicate.")
|
|
else:
|
|
nodelist = range(0, sum(sizes))
|
|
|
|
# Setup the graph conditionally to the directed switch.
|
|
block_range = range(len(sizes))
|
|
if directed:
|
|
g = nx.DiGraph()
|
|
block_iter = itertools.product(block_range, block_range)
|
|
else:
|
|
g = nx.Graph()
|
|
block_iter = itertools.combinations_with_replacement(block_range, 2)
|
|
# Split nodelist in a partition (list of sets).
|
|
size_cumsum = [sum(sizes[0:x]) for x in range(0, len(sizes) + 1)]
|
|
g.graph["partition"] = [
|
|
set(nodelist[size_cumsum[x] : size_cumsum[x + 1]])
|
|
for x in range(0, len(size_cumsum) - 1)
|
|
]
|
|
# Setup nodes and graph name
|
|
for block_id, nodes in enumerate(g.graph["partition"]):
|
|
for node in nodes:
|
|
g.add_node(node, block=block_id)
|
|
|
|
g.name = "stochastic_block_model"
|
|
|
|
# Test for edge existence
|
|
parts = g.graph["partition"]
|
|
for i, j in block_iter:
|
|
if i == j:
|
|
if directed:
|
|
if selfloops:
|
|
edges = itertools.product(parts[i], parts[i])
|
|
else:
|
|
edges = itertools.permutations(parts[i], 2)
|
|
else:
|
|
edges = itertools.combinations(parts[i], 2)
|
|
if selfloops:
|
|
edges = itertools.chain(edges, zip(parts[i], parts[i]))
|
|
for e in edges:
|
|
if seed.random() < p[i][j]:
|
|
g.add_edge(*e)
|
|
else:
|
|
edges = itertools.product(parts[i], parts[j])
|
|
if sparse:
|
|
if p[i][j] == 1: # Test edges cases p_ij = 0 or 1
|
|
for e in edges:
|
|
g.add_edge(*e)
|
|
elif p[i][j] > 0:
|
|
while True:
|
|
try:
|
|
logrand = math.log(seed.random())
|
|
skip = math.floor(logrand / math.log(1 - p[i][j]))
|
|
# consume "skip" edges
|
|
next(itertools.islice(edges, skip, skip), None)
|
|
e = next(edges)
|
|
g.add_edge(*e) # __safe
|
|
except StopIteration:
|
|
break
|
|
else:
|
|
for e in edges:
|
|
if seed.random() < p[i][j]:
|
|
g.add_edge(*e) # __safe
|
|
return g
|
|
|
|
|
|
def _zipf_rv_below(gamma, xmin, threshold, seed):
|
|
"""Returns a random value chosen from the bounded Zipf distribution.
|
|
|
|
Repeatedly draws values from the Zipf distribution until the
|
|
threshold is met, then returns that value.
|
|
"""
|
|
result = nx.utils.zipf_rv(gamma, xmin, seed)
|
|
while result > threshold:
|
|
result = nx.utils.zipf_rv(gamma, xmin, seed)
|
|
return result
|
|
|
|
|
|
def _powerlaw_sequence(gamma, low, high, condition, length, max_iters, seed):
|
|
"""Returns a list of numbers obeying a constrained power law distribution.
|
|
|
|
``gamma`` and ``low`` are the parameters for the Zipf distribution.
|
|
|
|
``high`` is the maximum allowed value for values draw from the Zipf
|
|
distribution. For more information, see :func:`_zipf_rv_below`.
|
|
|
|
``condition`` and ``length`` are Boolean-valued functions on
|
|
lists. While generating the list, random values are drawn and
|
|
appended to the list until ``length`` is satisfied by the created
|
|
list. Once ``condition`` is satisfied, the sequence generated in
|
|
this way is returned.
|
|
|
|
``max_iters`` indicates the number of times to generate a list
|
|
satisfying ``length``. If the number of iterations exceeds this
|
|
value, :exc:`~networkx.exception.ExceededMaxIterations` is raised.
|
|
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
"""
|
|
for i in range(max_iters):
|
|
seq = []
|
|
while not length(seq):
|
|
seq.append(_zipf_rv_below(gamma, low, high, seed))
|
|
if condition(seq):
|
|
return seq
|
|
raise nx.ExceededMaxIterations("Could not create power law sequence")
|
|
|
|
|
|
def _hurwitz_zeta(x, q, tolerance):
|
|
"""The Hurwitz zeta function, or the Riemann zeta function of two arguments.
|
|
|
|
``x`` must be greater than one and ``q`` must be positive.
|
|
|
|
This function repeatedly computes subsequent partial sums until
|
|
convergence, as decided by ``tolerance``.
|
|
"""
|
|
z = 0
|
|
z_prev = -float("inf")
|
|
k = 0
|
|
while abs(z - z_prev) > tolerance:
|
|
z_prev = z
|
|
z += 1 / ((k + q) ** x)
|
|
k += 1
|
|
return z
|
|
|
|
|
|
def _generate_min_degree(gamma, average_degree, max_degree, tolerance, max_iters):
|
|
"""Returns a minimum degree from the given average degree."""
|
|
# Defines zeta function whether or not Scipy is available
|
|
try:
|
|
from scipy.special import zeta
|
|
except ImportError:
|
|
|
|
def zeta(x, q):
|
|
return _hurwitz_zeta(x, q, tolerance)
|
|
|
|
min_deg_top = max_degree
|
|
min_deg_bot = 1
|
|
min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
|
|
itrs = 0
|
|
mid_avg_deg = 0
|
|
while abs(mid_avg_deg - average_degree) > tolerance:
|
|
if itrs > max_iters:
|
|
raise nx.ExceededMaxIterations("Could not match average_degree")
|
|
mid_avg_deg = 0
|
|
for x in range(int(min_deg_mid), max_degree + 1):
|
|
mid_avg_deg += (x ** (-gamma + 1)) / zeta(gamma, min_deg_mid)
|
|
if mid_avg_deg > average_degree:
|
|
min_deg_top = min_deg_mid
|
|
min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
|
|
else:
|
|
min_deg_bot = min_deg_mid
|
|
min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
|
|
itrs += 1
|
|
# return int(min_deg_mid + 0.5)
|
|
return round(min_deg_mid)
|
|
|
|
|
|
def _generate_communities(degree_seq, community_sizes, mu, max_iters, seed):
|
|
"""Returns a list of sets, each of which represents a community.
|
|
|
|
``degree_seq`` is the degree sequence that must be met by the
|
|
graph.
|
|
|
|
``community_sizes`` is the community size distribution that must be
|
|
met by the generated list of sets.
|
|
|
|
``mu`` is a float in the interval [0, 1] indicating the fraction of
|
|
intra-community edges incident to each node.
|
|
|
|
``max_iters`` is the number of times to try to add a node to a
|
|
community. This must be greater than the length of
|
|
``degree_seq``, otherwise this function will always fail. If
|
|
the number of iterations exceeds this value,
|
|
:exc:`~networkx.exception.ExceededMaxIterations` is raised.
|
|
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
|
|
The communities returned by this are sets of integers in the set {0,
|
|
..., *n* - 1}, where *n* is the length of ``degree_seq``.
|
|
|
|
"""
|
|
# This assumes the nodes in the graph will be natural numbers.
|
|
result = [set() for _ in community_sizes]
|
|
n = len(degree_seq)
|
|
free = list(range(n))
|
|
for i in range(max_iters):
|
|
v = free.pop()
|
|
c = seed.choice(range(len(community_sizes)))
|
|
# s = int(degree_seq[v] * (1 - mu) + 0.5)
|
|
s = round(degree_seq[v] * (1 - mu))
|
|
# If the community is large enough, add the node to the chosen
|
|
# community. Otherwise, return it to the list of unaffiliated
|
|
# nodes.
|
|
if s < community_sizes[c]:
|
|
result[c].add(v)
|
|
else:
|
|
free.append(v)
|
|
# If the community is too big, remove a node from it.
|
|
if len(result[c]) > community_sizes[c]:
|
|
free.append(result[c].pop())
|
|
if not free:
|
|
return result
|
|
msg = "Could not assign communities; try increasing min_community"
|
|
raise nx.ExceededMaxIterations(msg)
|
|
|
|
|
|
@py_random_state(11)
|
|
def LFR_benchmark_graph(
|
|
n,
|
|
tau1,
|
|
tau2,
|
|
mu,
|
|
average_degree=None,
|
|
min_degree=None,
|
|
max_degree=None,
|
|
min_community=None,
|
|
max_community=None,
|
|
tol=1.0e-7,
|
|
max_iters=500,
|
|
seed=None,
|
|
):
|
|
r"""Returns the LFR benchmark graph.
|
|
|
|
This algorithm proceeds as follows:
|
|
|
|
1) Find a degree sequence with a power law distribution, and minimum
|
|
value ``min_degree``, which has approximate average degree
|
|
``average_degree``. This is accomplished by either
|
|
|
|
a) specifying ``min_degree`` and not ``average_degree``,
|
|
b) specifying ``average_degree`` and not ``min_degree``, in which
|
|
case a suitable minimum degree will be found.
|
|
|
|
``max_degree`` can also be specified, otherwise it will be set to
|
|
``n``. Each node *u* will have `\mu \mathrm{deg}(u)` edges
|
|
joining it to nodes in communities other than its own and `(1 -
|
|
\mu) \mathrm{deg}(u)` edges joining it to nodes in its own
|
|
community.
|
|
2) Generate community sizes according to a power law distribution
|
|
with exponent ``tau2``. If ``min_community`` and
|
|
``max_community`` are not specified they will be selected to be
|
|
``min_degree`` and ``max_degree``, respectively. Community sizes
|
|
are generated until the sum of their sizes equals ``n``.
|
|
3) Each node will be randomly assigned a community with the
|
|
condition that the community is large enough for the node's
|
|
intra-community degree, `(1 - \mu) \mathrm{deg}(u)` as
|
|
described in step 2. If a community grows too large, a random node
|
|
will be selected for reassignment to a new community, until all
|
|
nodes have been assigned a community.
|
|
4) Each node *u* then adds `(1 - \mu) \mathrm{deg}(u)`
|
|
intra-community edges and `\mu \mathrm{deg}(u)` inter-community
|
|
edges.
|
|
|
|
Parameters
|
|
----------
|
|
n : int
|
|
Number of nodes in the created graph.
|
|
|
|
tau1 : float
|
|
Power law exponent for the degree distribution of the created
|
|
graph. This value must be strictly greater than one.
|
|
|
|
tau2 : float
|
|
Power law exponent for the community size distribution in the
|
|
created graph. This value must be strictly greater than one.
|
|
|
|
mu : float
|
|
Fraction of inter-community edges incident to each node. This
|
|
value must be in the interval [0, 1].
|
|
|
|
average_degree : float
|
|
Desired average degree of nodes in the created graph. This value
|
|
must be in the interval [0, *n*]. Exactly one of this and
|
|
``min_degree`` must be specified, otherwise a
|
|
:exc:`NetworkXError` is raised.
|
|
|
|
min_degree : int
|
|
Minimum degree of nodes in the created graph. This value must be
|
|
in the interval [0, *n*]. Exactly one of this and
|
|
``average_degree`` must be specified, otherwise a
|
|
:exc:`NetworkXError` is raised.
|
|
|
|
max_degree : int
|
|
Maximum degree of nodes in the created graph. If not specified,
|
|
this is set to ``n``, the total number of nodes in the graph.
|
|
|
|
min_community : int
|
|
Minimum size of communities in the graph. If not specified, this
|
|
is set to ``min_degree``.
|
|
|
|
max_community : int
|
|
Maximum size of communities in the graph. If not specified, this
|
|
is set to ``n``, the total number of nodes in the graph.
|
|
|
|
tol : float
|
|
Tolerance when comparing floats, specifically when comparing
|
|
average degree values.
|
|
|
|
max_iters : int
|
|
Maximum number of iterations to try to create the community sizes,
|
|
degree distribution, and community affiliations.
|
|
|
|
seed : integer, random_state, or None (default)
|
|
Indicator of random number generation state.
|
|
See :ref:`Randomness<randomness>`.
|
|
|
|
Returns
|
|
-------
|
|
G : NetworkX graph
|
|
The LFR benchmark graph generated according to the specified
|
|
parameters.
|
|
|
|
Each node in the graph has a node attribute ``'community'`` that
|
|
stores the community (that is, the set of nodes) that includes
|
|
it.
|
|
|
|
Raises
|
|
------
|
|
NetworkXError
|
|
If any of the parameters do not meet their upper and lower bounds:
|
|
|
|
- ``tau1`` and ``tau2`` must be strictly greater than 1.
|
|
- ``mu`` must be in [0, 1].
|
|
- ``max_degree`` must be in {1, ..., *n*}.
|
|
- ``min_community`` and ``max_community`` must be in {0, ...,
|
|
*n*}.
|
|
|
|
If not exactly one of ``average_degree`` and ``min_degree`` is
|
|
specified.
|
|
|
|
If ``min_degree`` is not specified and a suitable ``min_degree``
|
|
cannot be found.
|
|
|
|
ExceededMaxIterations
|
|
If a valid degree sequence cannot be created within
|
|
``max_iters`` number of iterations.
|
|
|
|
If a valid set of community sizes cannot be created within
|
|
``max_iters`` number of iterations.
|
|
|
|
If a valid community assignment cannot be created within ``10 *
|
|
n * max_iters`` number of iterations.
|
|
|
|
Examples
|
|
--------
|
|
Basic usage::
|
|
|
|
>>> from networkx.generators.community import LFR_benchmark_graph
|
|
>>> n = 250
|
|
>>> tau1 = 3
|
|
>>> tau2 = 1.5
|
|
>>> mu = 0.1
|
|
>>> G = LFR_benchmark_graph(
|
|
... n, tau1, tau2, mu, average_degree=5, min_community=20, seed=10
|
|
... )
|
|
|
|
Continuing the example above, you can get the communities from the
|
|
node attributes of the graph::
|
|
|
|
>>> communities = {frozenset(G.nodes[v]["community"]) for v in G}
|
|
|
|
Notes
|
|
-----
|
|
This algorithm differs slightly from the original way it was
|
|
presented in [1].
|
|
|
|
1) Rather than connecting the graph via a configuration model then
|
|
rewiring to match the intra-community and inter-community
|
|
degrees, we do this wiring explicitly at the end, which should be
|
|
equivalent.
|
|
2) The code posted on the author's website [2] calculates the random
|
|
power law distributed variables and their average using
|
|
continuous approximations, whereas we use the discrete
|
|
distributions here as both degree and community size are
|
|
discrete.
|
|
|
|
Though the authors describe the algorithm as quite robust, testing
|
|
during development indicates that a somewhat narrower parameter set
|
|
is likely to successfully produce a graph. Some suggestions have
|
|
been provided in the event of exceptions.
|
|
|
|
References
|
|
----------
|
|
.. [1] "Benchmark graphs for testing community detection algorithms",
|
|
Andrea Lancichinetti, Santo Fortunato, and Filippo Radicchi,
|
|
Phys. Rev. E 78, 046110 2008
|
|
.. [2] https://www.santofortunato.net/resources
|
|
|
|
"""
|
|
# Perform some basic parameter validation.
|
|
if not tau1 > 1:
|
|
raise nx.NetworkXError("tau1 must be greater than one")
|
|
if not tau2 > 1:
|
|
raise nx.NetworkXError("tau2 must be greater than one")
|
|
if not 0 <= mu <= 1:
|
|
raise nx.NetworkXError("mu must be in the interval [0, 1]")
|
|
|
|
# Validate parameters for generating the degree sequence.
|
|
if max_degree is None:
|
|
max_degree = n
|
|
elif not 0 < max_degree <= n:
|
|
raise nx.NetworkXError("max_degree must be in the interval (0, n]")
|
|
if not ((min_degree is None) ^ (average_degree is None)):
|
|
raise nx.NetworkXError(
|
|
"Must assign exactly one of min_degree and" " average_degree"
|
|
)
|
|
if min_degree is None:
|
|
min_degree = _generate_min_degree(
|
|
tau1, average_degree, max_degree, tol, max_iters
|
|
)
|
|
|
|
# Generate a degree sequence with a power law distribution.
|
|
low, high = min_degree, max_degree
|
|
|
|
def condition(seq):
|
|
return sum(seq) % 2 == 0
|
|
|
|
def length(seq):
|
|
return len(seq) >= n
|
|
|
|
deg_seq = _powerlaw_sequence(tau1, low, high, condition, length, max_iters, seed)
|
|
|
|
# Validate parameters for generating the community size sequence.
|
|
if min_community is None:
|
|
min_community = min(deg_seq)
|
|
if max_community is None:
|
|
max_community = max(deg_seq)
|
|
|
|
# Generate a community size sequence with a power law distribution.
|
|
#
|
|
# TODO The original code incremented the number of iterations each
|
|
# time a new Zipf random value was drawn from the distribution. This
|
|
# differed from the way the number of iterations was incremented in
|
|
# `_powerlaw_degree_sequence`, so this code was changed to match
|
|
# that one. As a result, this code is allowed many more chances to
|
|
# generate a valid community size sequence.
|
|
low, high = min_community, max_community
|
|
|
|
def condition(seq):
|
|
return sum(seq) == n
|
|
|
|
def length(seq):
|
|
return sum(seq) >= n
|
|
|
|
comms = _powerlaw_sequence(tau2, low, high, condition, length, max_iters, seed)
|
|
|
|
# Generate the communities based on the given degree sequence and
|
|
# community sizes.
|
|
max_iters *= 10 * n
|
|
communities = _generate_communities(deg_seq, comms, mu, max_iters, seed)
|
|
|
|
# Finally, generate the benchmark graph based on the given
|
|
# communities, joining nodes according to the intra- and
|
|
# inter-community degrees.
|
|
G = nx.Graph()
|
|
G.add_nodes_from(range(n))
|
|
for c in communities:
|
|
for u in c:
|
|
while G.degree(u) < round(deg_seq[u] * (1 - mu)):
|
|
v = seed.choice(list(c))
|
|
G.add_edge(u, v)
|
|
while G.degree(u) < deg_seq[u]:
|
|
v = seed.choice(range(n))
|
|
if v not in c:
|
|
G.add_edge(u, v)
|
|
G.nodes[u]["community"] = c
|
|
return G
|