# Node Clustering¶

Algorithms falling in this category generates communities composed by nodes.
The communities can represent neat, *crisp*, partition as well as *overlapping* or even *fuzzy* ones.

## Crisp Communities¶

A clustering is said to be a *partition* if each node belongs to one and only one community.
Methods in this subclass returns as result a `NodeClustering`

object instance.

`agdl` (g, number_communities, …) |
AGDL is a graph-based agglomerative algorithm, for clustering high-dimensional data. |

`async_fluid` (g, k) |
Fluid Communities (FluidC) is based on the simple idea of fluids (i.e., communities) interacting in an environment (i.e., a non-complete graph), expanding and contracting. |

`cpm` (g[, initial_membership, weights, …]) |
CPM is a Leiden model where the quality function to optimize is: |

`der` (g[, walk_len, threshold, iter_bound]) |
DER is a Diffusion Entropy Reducer graph clustering algorithm. |

`eigenvector` (g) |
Newman’s leading eigenvector method for detecting community structure based on modularity. |

`em` (g, k) |
EM is based on based on a mixture model. |

`gdmp2` (g[, min_threshold]) |
Gdmp2 is a method for identifying a set of dense subgraphs of a given sparse graph. |

`girvan_newman` (g, level) |
The Girvan–Newman algorithm detects communities by progressively removing edges from the original graph. |

`greedy_modularity` (g[, weight]) |
The CNM algorithm uses the modularity to find the communities strcutures. |

`infomap` (g) |
Infomap is based on ideas of information theory. |

`label_propagation` (g) |
The Label Propagation algorithm (LPA) detects communities using network structure alone. |

`leiden` (g[, initial_membership, weights]) |
The Leiden algorithm is an improvement of the Louvain algorithm. |

`louvain` (g[, weight, resolution, randomize]) |
Louvain maximizes a modularity score for each community. |

`rber_pots` (g[, initial_membership, weights, …]) |
rber_pots is a Leiden model where the quality function to optimize is: |

`rb_pots` (g[, initial_membership, weights, …]) |
Rb_pots is a Leiden model where the quality function to optimize is: |

`scan` (g, epsilon, mu) |
SCAN (Structural Clustering Algorithm for Networks) is an algorithm which detects clusters, hubs and outliers in networks. |

`significance_communities` (g[, …]) |
Significance_communities is a Leiden model where the quality function to optimize is: |

`spinglass` (g) |
Spinglass relies on an analogy between a very popular statistical mechanic model called Potts spin glass, and the community structure. |

`surprise_communities` (g[, …]) |
Surprise_communities is a Leiden model where the quality function to optimize is: |

`walktrap` (g) |
walktrap is an approach based on random walks. |

`sbm_dl` (g[, B_min, B_max, deg_corr]) |
Efficient Monte Carlo and greedy heuristic for the inference of stochastic block models. |

`sbm_dl_nested` (g[, B_min, B_max, deg_corr]) |
Efficient Monte Carlo and greedy heuristic for the inference of stochastic block models. |

## Overlapping Communities¶

A clustering is said to be *overlapping* if any generic node can be assigned to more than one community.
Methods in this subclass returns as result a `NodeClustering`

object instance.

`angel` (g, threshold[, min_community_size]) |
Angel is a node-centric bottom-up community discovery algorithm. |

`big_clam` (g[, number_communities]) |
BigClam is an overlapping community detection method that scales to large networks. |

`conga` (g, number_communities) |
CONGA (Cluster-Overlap Newman Girvan Algorithm) is an algorithm for discovering overlapping communities. |

`congo` (g, number_communities[, height]) |
CONGO (CONGA Optimized) is an optimization of the CONGA algortithm. |

`demon` (g, epsilon[, min_com_size]) |
Demon is a node-centric bottom-up overlapping community discovery algorithm. |

`ego_networks` (g[, level]) |
Ego-networks returns overlapping communities centered at each nodes within a given radius. |

`kclique` (g, k) |
Find k-clique communities in graph using the percolation method. |

`lais2` (g) |
LAIS2 is an overlapping community discovery algorithm based on the density function. |

`lemon` (graph, seeds[, min_com_size, …]) |
Lemon is a large scale overlapping community detection method based on local expansion via minimum one norm. |

`lfm` (g, alpha) |
LFM is based on the local optimization of a fitness function. |

`multicom` (g, seed_node) |
MULTICOM is an algorithm for detecting multiple local communities, possibly overlapping, by expanding the initial seed set. |

`node_perception` (g, threshold, overlap_threshold) |
Node perception is based on the idea of joining together small sets of nodes. |

`overlapping_seed_set_expansion` (g, seeds[, …]) |
OSSE is an overlapping community detection algorithm optimizing the conductance community score The algorithm uses a seed set expansion approach; the key idea is to find good seeds, and then expand these seed sets using the personalized PageRank clustering procedure. |

`slpa` (g[, t, r]) |
SLPA is an overlapping community discovery that extends tha LPA. |

## Fuzzy Communities¶

A clustering is said to be a *fuzzy* if each node can belongs (with a different degree of likelihood) to more than one community.
Methods in this subclass returns as result a `FuzzyNodeClustering`

object instance.

`frc_fgsn` (g, theta, eps, r) |
Fuzzy-Rough Community Detection on Fuzzy Granular model of Social Network. |