# python-igraph API reference

List of all classes, functions and methods in python-igraph

module documentation

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_leading_eigenvector_naive` Naive implementation of Newman's eigenvector community structure detection. 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.
def _community_edge_betweenness(graph, clusters=None, directed=True, weights=None):

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 which 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):

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.

 Parameters graph Undocumented weights edge attribute name or a list containing edge weights Returns an appropriate `VertexDendrogram` object. Unknown Field: newfield ref Reference Unknown Field: ref A Clauset, MEJ Newman and C Moore: Finding community structure in very large networks. Phys Rev E 70, 066111 (2004).
def _community_infomap(graph, edge_weights=None, vertex_weights=None, trials=10):

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

 Parameters graph Undocumented edge_weights name of an edge attribute or a list containing edge weights. vertex_weights name of an 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. Unknown Field: newfield ref Reference Unknown Field: ref 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.
def _community_label_propagation(graph, weights=None, initial=None, fixed=None):

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.

 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. Unknown Field: newfield ref Reference Unknown Field: ref 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.

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.

 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. Unknown Field: newfield ref Reference Unknown Field: ref MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087

Naive implementation of Newman's eigenvector community structure detection.

This function splits the network into two components according to the leading eigenvector of the modularity matrix and then recursively takes the given number of steps by splitting the communities as individual networks. This is not the correct way, however, see the reference for explanation. Consider using the correct `Graph.community_leading_eigenvector` method instead.

 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. return_merges whether the returned object should be a dendrogram instead of a single clustering. Returns an appropriate `VertexClustering` or `VertexDendrogram` object. Unknown Field: newfield ref Reference Unknown Field: ref MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087
def _community_leiden(graph, objective_function='CPM', weights=None, resolution_parameter=1.0, beta=0.01, initial_membership=None, n_iterations=2, node_weights=None):

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

 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_parameter 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. Returns an appropriate `VertexClustering` object. Unknown Field: newfield ref Reference Unknown Field: ref 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
def _community_multilevel(graph, weights=None, return_levels=False):

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 shrank to a single vertex (while keeping the total weight of the adjacent edges) and the process continues on the next level. The algorithm stops when it is not possible to increase the modularity any more after shrinking the communities to vertices.

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

 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. Returns a list of `VertexClustering` objects, one corresponding to each level (if return_levels is True), or a `VertexClustering` corresponding to the best modularity. Unknown Field: newfield ref Reference Unknown Field: ref 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
def _community_optimal_modularity(graph, *args, **kwds):

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):

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

 Parameters graph Undocumented *args Undocumented **kwds 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. Unknown Field: newfield ref Reference Unknown Field: ref 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.
def _community_walktrap(graph, weights=None, steps=4):

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.

 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. Unknown Field: newfield ref Reference Unknown Field: ref Pascal Pons, Matthieu Latapy: Computing communities in large networks using random walks, http://arxiv.org/abs/physics/0512106.
def _k_core(graph, *args):

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):

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 − 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). 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.

 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. Returns the modularity score Unknown Field: newfield ref Reference Unknown Field: ref MEJ Newman and M Girvan: Finding and evaluating community structure in networks. Phys Rev E 69 026113, 2004.