search in docstrings

Search bar offers the following options:

- Term presence. The below example searches for documents that must contain “foo”, might contain “bar” and must not contain “baz”: `+foo bar -baz`
- Wildcards. The below example searches for documents with words beginning with “foo”: `foo*`
- Search in specific fields. The following search matches all objects in "twisted.mail" that matches “search”: `+qname:twisted.mail.* +search`

  Possible fields: 'name', 'qname' (fully qualified name), 'docstring', and 'kind'. Last two fields are only applicable if "search in docstrings" is enabled.

- Fuzzy matches. The following search matches all documents that have a word within 1 edit distance of “foo”: `foo~1`

Results provided by Lunr.js

# ``igraph`.`community``

module documentation
(source)

Undocumented

Function | `_community_edge_betweenness` | Community structure based on the betweenness of the edges in the network.
Function | `_community_fastgreedy` | Community structure based on the greedy optimization of modularity.
Function | `_community_infomap` | Finds the community structure of the network according to the Infomap method of Martin Rosvall and Carl T. Bergstrom.
Function | `_community_label_propagation` | Finds the community structure of the graph according to the label propagation method of Raghavan et al.
Function | `_community_leading_eigenvector` | Newman's leading eigenvector method for detecting community structure.
Function | `_community_leiden` | Finds the community structure of the graph using the Leiden algorithm of Traag, van Eck & Waltman.
Function | `_community_multilevel` | Community structure based on the multilevel algorithm of Blondel et al.
Function | `_community_optimal_modularity` | Calculates the optimal modularity score of the graph and the corresponding community structure.
Function | `_community_spinglass` | Finds the community structure of the graph according to the spinglass community detection method of Reichardt & Bornholdt.
Function | `_community_walktrap` | Community detection algorithm of Latapy & Pons, based on random walks.
Function | `_k_core` | Returns some k-cores of the graph.
Function | `_modularity` | Calculates the modularity score of the graph with respect to a given clustering.
Function | `_optimal_cluster_count_from_merges_and_modularity` | Helper function to find the optimal cluster count for a hierarchical clustering of a graph, given the merge matrix and the list of modularity values after each merge.

def _community_edge_betweenness(graph, clusters=None, directed=True, weights=None): (source)

Community structure based on the betweenness of the edges in the network.

The idea is that the betweenness of the edges connecting two communities is typically high, as many of the shortest paths between nodes in separate communities go through them. So we gradually remove the edge with the highest betweenness and recalculate the betweennesses after every removal. This way sooner or later the network falls of to separate components. The result of the clustering will be represented by a dendrogram.

Parameters
graph | Undocumented

clusters

the number of clusters we would like to see. This practically defines the "level" where we "cut" the dendrogram to get the membership vector of the vertices. If `None`, the dendrogram is cut at the level that maximizes the modularity when the graph is unweighted; otherwise the dendrogram is cut at at a single cluster (because cluster count selection based on modularities does not make sense for this method if not all the weights are equal).

directed | whether the directionality of the edges should be taken into account or not.
weights | name of an edge attribute or a list containing edge weights.
Returns
a `VertexDendrogram` object, initally cut at the maximum modularity or at the desired number of clusters.

def _community_fastgreedy(graph, weights=None): (source)

Community structure based on the greedy optimization of modularity.

This algorithm merges individual nodes into communities in a way that greedily maximizes the modularity score of the graph. It can be proven that if no merge can increase the current modularity score, the algorithm can be stopped since no further increase can be achieved.

This algorithm is said to run almost in linear time on sparse graphs.

Reference: A Clauset, MEJ Newman and C Moore: Finding community structure in very large networks. Phys Rev E 70, 066111 (2004).

Parameters
graph | Undocumented
weights | edge attribute name or a list containing edge weights
Returns
an appropriate `VertexDendrogram` object.

def _community_infomap(graph, edge_weights=None, vertex_weights=None, trials=10): (source)

Finds the community structure of the network according to the Infomap method of Martin Rosvall and Carl T. Bergstrom.

References

- M. Rosvall and C. T. Bergstrom: Maps of information flow reveal community structure in complex networks, PNAS 105, 1118 (2008). http://dx.doi.org/10.1073/pnas.0706851105, http://arxiv.org/abs/0707.0609.
- M. Rosvall, D. Axelsson, and C. T. Bergstrom: The map equation, Eur Phys. J Special Topics 178, 13 (2009). http://dx.doi.org/10.1140/epjst/e2010-01179-1, http://arxiv.org/abs/0906.1405.

Parameters
graph | Undocumented
edge_weights | name of an edge attribute or a list containing edge weights.
vertex_weights | name of a vertex attribute or a list containing vertex weights.
trials | the number of attempts to partition the network.
Returns
an appropriate `VertexClustering` object with an extra attribute called `codelength` that stores the code length determined by the algorithm.

def _community_label_propagation(graph, weights=None, initial=None, fixed=None): (source)

Finds the community structure of the graph according to the label propagation method of Raghavan et al.

Initially, each vertex is assigned a different label. After that, each vertex chooses the dominant label in its neighbourhood in each iteration. Ties are broken randomly and the order in which the vertices are updated is randomized before every iteration. The algorithm ends when vertices reach a consensus.

Note that since ties are broken randomly, there is no guarantee that the algorithm returns the same community structure after each run. In fact, they frequently differ. See the paper of Raghavan et al. on how to come up with an aggregated community structure.

Also note that the community _labels_ (numbers) have no semantic meaning and igraph is free to re-number communities. If you use fixed labels, igraph may still re-number the communities, but co-community membership constraints will be respected: if you had two vertices with fixed labels that belonged to the same community, they will still be in the same community at the end. Similarly, if you had two vertices with fixed labels that belonged to different communities, they will still be in different communities at the end.

Reference: Raghavan, U.N. and Albert, R. and Kumara, S. Near linear time algorithm to detect community structures in large-scale networks. Phys Rev E 76:036106, 2007. http://arxiv.org/abs/0709.2938.

Parameters
graph | Undocumented
weights | name of an edge attribute or a list containing edge weights
initial | name of a vertex attribute or a list containing the initial vertex labels. Labels are identified by integers from zero to n− 1 where n is the number of vertices. Negative numbers may also be present in this vector, they represent unlabeled vertices.
fixed | a list of booleans for each vertex. `True` corresponds to vertices whose labeling should not change during the algorithm. It only makes sense if initial labels are also given. Unlabeled vertices cannot be fixed. It may also be the name of a vertex attribute; each attribute value will be interpreted as a Boolean.
Returns
an appropriate `VertexClustering` object.

def _community_leading_eigenvector(graph, clusters=None, weights=None, arpack_options=None): (source)

Newman's leading eigenvector method for detecting community structure.

This is the proper implementation of the recursive, divisive algorithm: each split is done by maximizing the modularity regarding the original network.

Reference: MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087

Parameters
graph | Undocumented
clusters | the desired number of communities. If `None`, the algorithm tries to do as many splits as possible. Note that the algorithm won't split a community further if the signs of the leading eigenvector are all the same, so the actual number of discovered communities can be less than the desired one.
weights | name of an edge attribute or a list containing edge weights.
arpack_options | an `ARPACKOptions` object used to fine-tune the ARPACK eigenvector calculation. If omitted, the module-level variable called `arpack_options` is used.
Returns
an appropriate `VertexClustering` object.

def _community_leiden(graph, objective_function='CPM', weights=None, resolution=1.0, beta=0.01, initial_membership=None, n_iterations=2, node_weights=None, **kwds): (source)

Finds the community structure of the graph using the Leiden algorithm of Traag, van Eck & Waltman.

Reference: Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvain to Leiden: guaranteeing well-connected communities. Scientific Reports, 9(1), 5233. doi: 10.1038/s41598-019-41695-z

Parameters
graph | Undocumented
objective_function | whether to use the Constant Potts Model (CPM) or modularity. Must be either `"CPM"` or `"modularity"`.
weights | edge weights to be used. Can be a sequence or iterable or even an edge attribute name.
resolution | the resolution parameter to use. Higher resolutions lead to more smaller communities, while lower resolutions lead to fewer larger communities.
beta | parameter affecting the randomness in the Leiden algorithm. This affects only the refinement step of the algorithm.
initial_membership | if provided, the Leiden algorithm will try to improve this provided membership. If no argument is provided, the aglorithm simply starts from the singleton partition.
n_iterations | the number of iterations to iterate the Leiden algorithm. Each iteration may improve the partition further. Using a negative number of iterations will run until a stable iteration is encountered (i.e. the quality was not increased during that iteration).
node_weights | the node weights used in the Leiden algorithm. If this is not provided, it will be automatically determined on the basis of whether you want to use CPM or modularity. If you do provide this, please make sure that you understand what you are doing.
**kwds | Undocumented
Returns
an appropriate `VertexClustering` object with an extra attribute called `quality` that stores the value of the internal quality function optimized by the algorithm.

def _community_multilevel(graph, weights=None, return_levels=False, resolution=1): (source)

Community structure based on the multilevel algorithm of Blondel et al.

This is a bottom-up algorithm: initially every vertex belongs to a separate community, and vertices are moved between communities iteratively in a way that maximizes the vertices' local contribution to the overall modularity score. When a consensus is reached (i.e. no single move would increase the modularity score), every community in the original graph is shrunk to a single vertex (while keeping the total weight of the incident edges) and the process continues on the next level. The algorithm stops when it is not possible to increase the modularity anymore after shrinking the communities to vertices.

This algorithm is said to run almost in linear time on sparse graphs.

Reference: VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large networks, J Stat Mech P10008 (2008). http://arxiv.org/abs/0803.0476

Parameters
graph | Undocumented
weights | edge attribute name or a list containing edge weights
return_levels | if `True`, the communities at each level are returned in a list. If `False`, only the community structure with the best modularity is returned.
resolution | the resolution parameter to use in the modularity measure. Smaller values result in a smaller number of larger clusters, while higher values yield a large number of small clusters. The classical modularity measure assumes a resolution parameter of 1.
Returns
a list of `VertexClustering` objects, one corresponding to each level (if `return_levels` is `True`), or a `VertexClustering` corresponding to the best modularity.

def _community_optimal_modularity(graph, *args, **kwds): (source)

Calculates the optimal modularity score of the graph and the corresponding community structure.

This function uses the GNU Linear Programming Kit to solve a large integer optimization problem in order to find the optimal modularity score and the corresponding community structure, therefore it is unlikely to work for graphs larger than a few (less than a hundred) vertices. Consider using one of the heuristic approaches instead if you have such a large graph.

Returns
the calculated membership vector and the corresponding modularity in a tuple.

def _community_spinglass(graph, *args, **kwds): (source)

Finds the community structure of the graph according to the spinglass community detection method of Reichardt & Bornholdt.

References

- Reichardt J and Bornholdt S: Statistical mechanics of community detection. Phys Rev E 74:016110 (2006). http://arxiv.org/abs/cond-mat/0603718.
- Traag VA and Bruggeman J: Community detection in networks with positive and negative links. Phys Rev E 80:036115 (2009). http://arxiv.org/abs/0811.2329.

Parameters
graph | Undocumented
*args | Undocumented
weights | edge weights to be used. Can be a sequence or iterable or even an edge attribute name.
spins | integer, the number of spins to use. This is the upper limit for the number of communities. It is not a problem to supply a (reasonably) big number here, in which case some spin states will be unpopulated.
parupdate | whether to update the spins of the vertices in parallel (synchronously) or not
start_temp | the starting temperature
stop_temp | the stop temperature
cool_fact | cooling factor for the simulated annealing
update_rule | specifies the null model of the simulation. Possible values are `"config"` (a random graph with the same vertex degrees as the input graph) or `"simple"` (a random graph with the same number of edges)
gamma | the gamma argument of the algorithm, specifying the balance between the importance of present and missing edges within a community. The default value of 1.0 assigns equal importance to both of them.
implementation | currently igraph contains two implementations of the spinglass community detection algorithm. The faster original implementation is the default. The other implementation is able to take into account negative weights, this can be chosen by setting `implementation` to `"neg"`

lambda_

the lambda argument of the algorithm, which specifies the balance between the importance of present and missing negatively weighted edges within a community. Smaller values of lambda lead to communities with less negative intra-connectivity. If the argument is zero, the algorithm reduces to a graph coloring algorithm, using the number of spins as colors. This argument is ignored if the original implementation is used. Note the underscore at the end of the argument name; this is due to the fact that lambda is a reserved keyword in Python.

Returns
an appropriate `VertexClustering` object.

def _community_walktrap(graph, weights=None, steps=4): (source)

Community detection algorithm of Latapy & Pons, based on random walks.

The basic idea of the algorithm is that short random walks tend to stay in the same community. The result of the clustering will be represented as a dendrogram.

Reference: Pascal Pons, Matthieu Latapy: Computing communities in large networks using random walks, http://arxiv.org/abs/physics/0512106.

Parameters
graph | Undocumented
weights | name of an edge attribute or a list containing edge weights
steps | length of random walks to perform
Returns
a `VertexDendrogram` object, initially cut at the maximum modularity.

def _k_core(graph, *args): (source)

Returns some k-cores of the graph.

The method accepts an arbitrary number of arguments representing the desired indices of the k-cores to be returned. The arguments can also be lists or tuples. The result is a single `Graph` object if an only integer argument was given, otherwise the result is a list of `Graph` objects representing the desired k-cores in the order the arguments were specified. If no argument is given, returns all k-cores in increasing order of k.

def _modularity(self, membership, weights=None, resolution=1, directed=True): (source)

Calculates the modularity score of the graph with respect to a given clustering.

The modularity of a graph w.r.t. some division measures how good the division is, or how separated are the different vertex types from each other. It's defined as Q= 1 ⁄ (2m)*sum(Aij−gamma*ki*kj⁄ (2m)delta(ci,cj),i,j). m is the number of edges, Aij is the element of the A adjacency matrix in row i and column j, ki is the degree of node i, kj is the degree of node j, and Ci and `cj` are the types of the two vertices (i and j), and gamma is a resolution parameter that defaults to 1 for the classical definition of modularity. delta(x,y) is one iff x=y, 0 otherwise.

If edge weights are given, the definition of modularity is modified as follows: Aij becomes the weight of the corresponding edge, ki is the total weight of edges adjacent to vertex i, kj is the total weight of edges adjacent to vertex j and m is the total edge weight in the graph.

Reference: MEJ Newman and M Girvan: Finding and evaluating community structure in networks. Phys Rev E 69 026113, 2004.

Parameters
self | Undocumented
membership | a membership list or a `VertexClustering` object
weights | optional edge weights or `None` if all edges are weighed equally. Attribute names are also allowed.
resolution | the resolution parameter gamma in the formula above. The classical definition of modularity is retrieved when the resolution parameter is set to 1.
directed | whether to consider edge directions if the graph is directed. `True` will use the directed variant of the modularity measure where the in- and out-degrees of nodes are treated separately; `False` will treat directed graphs as undirected.
Returns
the modularity score

def _optimal_cluster_count_from_merges_and_modularity(graph, merges: `Sequence[Tuple[int, int]]`, qs: `List[float]`) -> `float`: (source)

Helper function to find the optimal cluster count for a hierarchical clustering of a graph, given the merge matrix and the list of modularity values after each merge.

Reverses the modularity vector as a side effect.