Louvain (Graphoscope)

Graphoscope

Documentation for 0.5.1-preview.1

Louvain Type

Namespace: Graphoscope.Algorithms
Assembly: Graphoscope.dll
Base Type: obj

Louvain method for community detection

Constructors

Constructor	Description
`Louvain()` Full Usage: `Louvain()` Returns: `Louvain`	Returns: `Louvain`

Static members

Static member	Description
`Louvain.louvain modularityIncreaseThreshold weightF graph` Full Usage: `Louvain.louvain modularityIncreaseThreshold weightF graph` Parameters: modularityIncreaseThreshold : `float` - Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. weightF : `'Edge -> float` graph : `AdjGraph<'Node, 'Label, 'Edge>` - FGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new FGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.	Takes a FGraph and returns a new graph whose NodeData has been transformed into tupels, where the second part is the community according to modularity-optimization by the Louvain Algorithm (Blondel, Vincent D; Guillaume, Jean-Loup; Lambiotte, Renaud; Lefebvre, Etienne (9 October 2008). "Fast unfolding of communities in large networks". Journal of Statistical Mechanics: Theory and Experiment. 2008 ). modularityIncreaseThreshold : `float` Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. weightF : `'Edge -> float` graph : `AdjGraph<'Node, 'Label, 'Edge>` FGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new FGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.
`Louvain.louvainCommunities (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Full Usage: `Louvain.louvainCommunities (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Parameters: graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse ?getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[]`	Finds optimal partition of graph nodes into communities using Louvain method. graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse ?getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[]`
`Louvain.louvainCommunities (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Full Usage: `Louvain.louvainCommunities (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Parameters: graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse ?getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[]`	Finds optimal partition of graph nodes into communities using Louvain method. graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse ?getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[]`
`Louvain.louvainPartitions (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Full Usage: `Louvain.louvainPartitions (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Parameters: graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse ?getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[][]`	Returns all partitions found at each level of Louvain method. graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse ?getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[][]`
`Louvain.louvainPartitions (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Full Usage: `Louvain.louvainPartitions (graph, ?getWeight, ?resolution, ?threshold, ?rng)` Parameters: graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse ?getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[][]`	Returns all partitions found at each level of Louvain method. graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse ?getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. ?resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 ?threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 ?rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. Returns: `Set<'NodeKey>[][]`
`Louvain.louvainPartitionsDiGraph getWeight rng resolution threshold graph` Full Usage: `Louvain.louvainPartitionsDiGraph getWeight rng resolution threshold graph` Parameters: getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse Returns: `Set<'NodeKey>[][]`	Returns all partitions found at each level of Louvain method. getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 graph : `DiGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse Returns: `Set<'NodeKey>[][]`
`Louvain.louvainPartitionsUndirected getWeight rng resolution threshold graph` Full Usage: `Louvain.louvainPartitionsUndirected getWeight rng resolution threshold graph` Parameters: getWeight : `'EdgeData -> float` - Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. rng : `unit -> float` - The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. resolution : `float` - If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 threshold : `float` - The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` - The graph to analyse Returns: `Set<'NodeKey>[][]`	Returns all partitions found at each level of Louvain method. getWeight : `'EdgeData -> float` Function to get the edge weight from 'EdgeData. Optional; defaults to each edge weight being equal to 1.0. rng : `unit -> float` The random number generator to be used in the initial ordering of the nodes in the graph. Optional; defaults to creating a System.Random object and calling `.NextDouble()` method on it. resolution : `float` If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Optional; default = 1.0 threshold : `float` The desired minimum modularity gain for each level of the algorithm Optional; default = 0.0000001 graph : `UndirectedGraph<'NodeKey, 'a, 'EdgeData>` The graph to analyse Returns: `Set<'NodeKey>[][]`
`Louvain.louvainRandom modularityIncreaseThreshold weightF graph` Full Usage: `Louvain.louvainRandom modularityIncreaseThreshold weightF graph` Parameters: modularityIncreaseThreshold : `float` - Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. weightF : `'Edge -> float` graph : `AdjGraph<'Node, 'Label, 'Edge>` - FGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new FGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.	Takes a FGraph and returns a new graph whose NodeData has been transformed into tupels, where the second part is the community according to modularity-optimization by the Louvain Algorithm (Blondel, Vincent D; Guillaume, Jean-Loup; Lambiotte, Renaud; Lefebvre, Etienne (9 October 2008). "Fast unfolding of communities in large networks". Journal of Statistical Mechanics: Theory and Experiment. 2008 ). modularityIncreaseThreshold : `float` Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. weightF : `'Edge -> float` graph : `AdjGraph<'Node, 'Label, 'Edge>` FGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new FGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.
`Louvain.louvainResolution randomized weightF modularityIncreaseThreshold resolution graph` Full Usage: `Louvain.louvainResolution randomized weightF modularityIncreaseThreshold resolution graph` Parameters: randomized : `bool` - Boolean, if true randomizes the order in which the vertices are checked. Else the calculations are ordered by the index of the vertices. weightF : `'Edge -> float` - Function to get an edgeweight out of the EdgeData modularityIncreaseThreshold : `float` - Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. resolution : `float` - The higher the resolution, the smaller the number of communities. The value has to be 1. or higher. Based on : "R. Lambiotte, J.-C. Delvenne, M. Barahona Laplacian Dynamics and Multiscale Modular Structure in Networks 2009", arXiv:0812.1770 [physics.soc-ph]. graph : `AdjGraph<'Node, 'Label, 'Edge>` - AdjGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new AdjGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.	Takes a AdjGraph and returns a new graph whose NodeData has been transformed into tupels, where the second part is the community according to modularity-optimization by the Louvain Algorithm (Blondel, Vincent D; Guillaume, Jean-Loup; Lambiotte, Renaud; Lefebvre, Etienne (9 October 2008). "Fast unfolding of communities in large networks". Journal of Statistical Mechanics: Theory and Experiment. 2008 ). randomized : `bool` Boolean, if true randomizes the order in which the vertices are checked. Else the calculations are ordered by the index of the vertices. weightF : `'Edge -> float` Function to get an edgeweight out of the EdgeData modularityIncreaseThreshold : `float` Threshold of modularity-difference that has to be exceeded in order to be recognized as a modularity-increase. The value has to be between 0. and 1. to get a meaningful result. The smaller the value, the longer the calculation takes. resolution : `float` The higher the resolution, the smaller the number of communities. The value has to be 1. or higher. Based on : "R. Lambiotte, J.-C. Delvenne, M. Barahona Laplacian Dynamics and Multiscale Modular Structure in Networks 2009", arXiv:0812.1770 [physics.soc-ph]. graph : `AdjGraph<'Node, 'Label, 'Edge>` AdjGraph, that is used as the template for the modularity optimization. Returns: `AdjGraph<'Node, ('Label * int), 'Edge>` A new AdjGraph whose NodeData has been transformed into tupels, where the second part is the community accorging to modularity-optimization.