Modularity Optimization
Glossary
 Directed

Directed trait. The algorithm is welldefined on a directed graph.
 Directed

Directed trait. The algorithm ignores the direction of the graph.
 Directed

Directed trait. The algorithm does not run on a directed graph.
 Undirected

Undirected trait. The algorithm is welldefined on an undirected graph.
 Undirected

Undirected trait. The algorithm ignores the undirectedness of the graph.
 Heterogeneous nodes

Heterogeneous nodes fully supported. The algorithm has the ability to distinguish between nodes of different types.
 Heterogeneous nodes

Heterogeneous nodes allowed. The algorithm treats all selected nodes similarly regardless of their label.
 Heterogeneous relationships

Heterogeneous relationships fully supported. The algorithm has the ability to distinguish between relationships of different types.
 Heterogeneous relationships

Heterogeneous relationships allowed. The algorithm treats all selected relationships similarly regardless of their type.
 Weighted relationships

Weighted trait. The algorithm supports a relationship property to be used as weight, specified via the relationshipWeightProperty configuration parameter.
 Weighted relationships

Weighted trait. The algorithm treats each relationship as equally important, discarding the value of any relationship weight.
Introduction
The Modularity Optimization algorithm tries to detect communities in the graph based on their modularity. Modularity is a measure of the structure of a graph, measuring the density of connections within a module or community. Graphs with a high modularity score will have many connections within a community but only few pointing outwards to other communities. The algorithm will explore for every node if its modularity score might increase if it changes its community to one of its neighboring nodes.
For more information on this algorithm, see:
Running this algorithm requires sufficient memory availability. Before running this algorithm, we recommend that you read Memory Estimation. 
Syntax
CALL gds.modularityOptimization.stream(graphName: String, configuration: Map)
YIELD
nodeId: Integer,
communityId: Integer
Name  Type  Default  Optional  Description 

graphName 
String 

no 
The name of a graph stored in the catalog. 
configuration 
Map 

yes 
Configuration for algorithmspecifics and/or graph filtering. 
Name  Type  Default  Optional  Description 

List of String 

yes 
Filter the named graph using the given node labels. Nodes with any of the given labels will be included. 

List of String 

yes 
Filter the named graph using the given relationship types. Relationships with any of the given types will be included. 

Integer 

yes 
The number of concurrent threads used for running the algorithm. 

String 

yes 
An ID that can be provided to more easily track the algorithm’s progress. 

Boolean 

yes 
If disabled the progress percentage will not be logged. 

Integer 

yes 
The maximum number of iterations to run. 

Float 

yes 
Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns. 

seedProperty 
String 

yes 
Used to define initial set of labels (must be a nonnegative number). 
consecutiveIds 
Boolean 

yes 
Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory). 
String 

yes 
Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. 

minCommunitySize 
Integer 

yes 
Only nodes inside communities larger or equal the given value are returned. 
Name  Type  Description 

nodeId 
Integer 
Node ID 
communityId 
Integer 
Community ID 
CALL gds.modularityOptimization.stats(graphName: String, configuration: Map)
YIELD
preProcessingMillis: Integer,
computeMillis: Integer,
postProcessingMillis: Integer,
communityCount: Integer,
communityDistribution: Map,
modularity: Float,
ranIterations: Integer,
didConverge: Boolean,
nodes: Integer,
configuration: Map
Name  Type  Default  Optional  Description 

graphName 
String 

no 
The name of a graph stored in the catalog. 
configuration 
Map 

yes 
Configuration for algorithmspecifics and/or graph filtering. 
Name  Type  Default  Optional  Description 

Integer 

yes 
The number of concurrent threads used for running the algorithm. Also provides the default value for 'readConcurrency' and 'writeConcurrency'. 

Integer 

yes 
The number of concurrent threads used for writing the result (applicable in WRITE mode). 

Boolean 

yes 
If disabled the progress percentage will not be logged. 
Name  Type  Default  Optional  Description 

Integer 
10 
yes 
The maximum number of iterations to run. 

Float 
0.0001 
yes 
Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns. 

seedProperty 
String 
n/a 
yes 
Used to define initial set of labels (must be a nonnegative number). 
consecutiveIds 
Boolean 
false 
yes 
Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory). 
String 
null 
yes 
Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. 
Name  Type  Description 

preProcessingMillis 
Integer 
Milliseconds for preprocessing the data. 
computeMillis 
Integer 
Milliseconds for running the algorithm. 
postProcessingMillis 
Integer 
Milliseconds for computing percentiles and community count. 
nodes 
Integer 
The number of nodes considered. 
didConverge 
Boolean 
True if the algorithm did converge to a stable modularity score within the provided number of maximum iterations. 
ranIterations 
Integer 
The number of iterations run. 
modularity 
Float 
The final modularity score. 
communityCount 
Integer 
The number of communities found. 
communityDistribution 
Map 
The containing min, max, mean as well as 50, 75, 90, 95, 99 and 999 percentile of community size. 
configuration 
Map 
The configuration used for running the algorithm. 
CALL gds.modularityOptimization.mutate(graphName: String, configuration: Map})
YIELD
preProcessingMillis: Integer,
computeMillis: Integer,
postProcessingMillis: Integer,
mutateMillis: Integer,
communityCount: Integer,
communityDistribution: Map,
modularity: Float,
ranIterations: Integer,
didConverge: Boolean,
nodes: Integer,
configuration: Map
Name  Type  Default  Optional  Description 

graphName 
String 

no 
The name of a graph stored in the catalog. 
configuration 
Map 

yes 
Configuration for algorithmspecifics and/or graph filtering. 
The configuration for the mutate
mode is similar to the write
mode.
Instead of specifying a writeProperty
, we need to specify a mutateProperty
.
Also, specifying writeConcurrency
is not possible in mutate
mode.
Name  Type  Description 

preProcessingMillis 
Integer 
Milliseconds for preprocessing the data. 
computeMillis 
Integer 
Milliseconds for running the algorithm. 
mutateMillis 
Integer 
Milliseconds for adding properties to the projected graph. 
postProcessingMillis 
Integer 
Milliseconds for computing percentiles and community count. 
nodes 
Integer 
The number of nodes considered. 
didConverge 
Boolean 
True if the algorithm did converge to a stable modularity score within the provided number of maximum iterations. 
ranIterations 
Integer 
The number of iterations run. 
modularity 
Float 
The final modularity score. 
communityCount 
Integer 
The number of communities found. 
communityDistribution 
Map 
The containing min, max, mean as well as 50, 75, 90, 95, 99 and 999 percentile of community size. 
configuration 
Map 
The configuration used for running the algorithm. 
CALL gds.modularityOptimization.write(graphName: String, configuration: Map})
YIELD
preProcessingMillis: Integer,
computeMillis: Integer,
postProcessingMillis: Integer,
writeMillis: Integer,
communityCount: Integer,
communityDistribution: Map,
modularity: Float,
ranIterations: Integer,
didConverge: Boolean,
nodes: Integer,
configuration: Map
Name  Type  Default  Optional  Description 

graphName 
String 

no 
The name of a graph stored in the catalog. 
configuration 
Map 

yes 
Configuration for algorithmspecifics and/or graph filtering. 
Name  Type  Default  Optional  Description 

Integer 

yes 
The number of concurrent threads used for running the algorithm. Also provides the default value for 'readConcurrency' and 'writeConcurrency'. 

Integer 

yes 
The number of concurrent threads used for writing the result (applicable in WRITE mode). 

Boolean 

yes 
If disabled the progress percentage will not be logged. 
Name  Type  Default  Optional  Description 

String 

yes 
Used to set the initial community for a node. The property value needs to be a number. 

String 

yes 
The property name written back the ID of the partition particular node belongs to. 

Integer 

yes 
The maximum number of iterations that the modularity optimization will run for each level. 

Float 

yes 
Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns. 

consecutiveIds 
Boolean 

yes 
Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory). 
String 

yes 
Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. 

minCommunitySize 
Integer 

yes 
Only community ids of communities with a size greater than or equal to the given value are written to Neo4j. 
Name  Type  Description 

preProcessingMillis 
Integer 
Milliseconds for preprocessing the data. 
computeMillis 
Integer 
Milliseconds for running the algorithm. 
writeMillis 
Integer 
Milliseconds for writing result data back. 
postProcessingMillis 
Integer 
Milliseconds for computing percentiles and community count. 
nodes 
Integer 
The number of nodes considered. 
didConverge 
Boolean 
True if the algorithm did converge to a stable modularity score within the provided number of maximum iterations. 
ranIterations 
Integer 
The number of iterations run. 
modularity 
Float 
The final modularity score. 
communityCount 
Integer 
The number of communities found. 
communityDistribution 
Map 
The containing min, max, mean as well as 50, 75, 90, 95, 99 and 999 percentile of community size. 
configuration 
Map 
The configuration used for running the algorithm. 
Examples
All the examples below should be run in an empty database. The examples use native projections as the norm, although Cypher projections can be used as well. 
Consider the graph created by the following Cypher statement:
CREATE
(a:Person {name:'Alice'})
, (b:Person {name:'Bridget'})
, (c:Person {name:'Charles'})
, (d:Person {name:'Doug'})
, (e:Person {name:'Elton'})
, (f:Person {name:'Frank'})
, (a)[:KNOWS {weight: 0.01}]>(b)
, (a)[:KNOWS {weight: 5.0}]>(e)
, (a)[:KNOWS {weight: 5.0}]>(f)
, (b)[:KNOWS {weight: 5.0}]>(c)
, (b)[:KNOWS {weight: 5.0}]>(d)
, (c)[:KNOWS {weight: 0.01}]>(e)
, (f)[:KNOWS {weight: 0.01}]>(d)
This graph consists of two center nodes "Alice" and "Bridget" each of which have two more neighbors. Additionally, each neighbor of "Alice" is connected to one of the neighbors of "Bridget". Looking at the weights of the relationships, it can be seen that the connections from the two center nodes to their neighbors are very strong, while connections between those groups are weak. Therefore the Modularity Optimization algorithm should detect two communities: "Alice" and "Bob" together with their neighbors respectively.
CALL gds.graph.project(
'myGraph',
'Person',
{
KNOWS: {
orientation: 'UNDIRECTED',
properties: ['weight']
}
})
Memory estimation
First off, we will estimate the cost of running the algorithm using the estimate
procedure.
This can be done with any execution mode.
We will use the write
mode in this example.
Estimating the algorithm is useful to understand the memory impact that running the algorithm on your graph will have.
When you later actually run the algorithm in one of the execution modes the system will perform an estimation.
If the estimation shows that there is a very high probability of the execution going over its memory limitations, the execution is prohibited.
To read more about this, see Automatic estimation and execution blocking.
For more details on estimate
in general, see Memory Estimation.
CALL gds.modularityOptimization.write.estimate('myGraph', { relationshipWeightProperty: 'weight', writeProperty: 'community' })
YIELD nodeCount, relationshipCount, bytesMin, bytesMax, requiredMemory
nodeCount  relationshipCount  bytesMin  bytesMax  requiredMemory 

6 
14 
5168 
5256 
"[5168 Bytes ... 5256 Bytes]" 
Stream
In the stream
execution mode, the algorithm returns the community for each node.
This allows us to inspect the results directly or postprocess them in Cypher without any side effects.
For more details on the stream
mode in general, see Stream.
CALL gds.modularityOptimization.stream('myGraph', { relationshipWeightProperty: 'weight' })
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY name
name  communityId 

"Alice" 
4 
"Bridget" 
1 
"Charles" 
1 
"Doug" 
1 
"Elton" 
4 
"Frank" 
4 
Stats
In the stats
execution mode, the algorithm returns a single row containing a summary of the algorithm result.
This execution mode does not have any side effects.
It can be useful for evaluating algorithm performance by inspecting the computeMillis
return item.
In the examples below we will omit returning the timings.
The full signature of the procedure can be found in the syntax section.
For more details on the stats
mode in general, see Stats.
CALL gds.modularityOptimization.stats('myGraph', { relationshipWeightProperty: 'weight' })
YIELD nodes, communityCount, ranIterations, didConverge
nodes  communityCount  ranIterations  didConverge 

6 
2 
2 
true 
Write
The write
execution mode extends the stats
mode with an important side effect: writing the community for each node as a property to the Neo4j database.
The name of the new property is specified using the mandatory configuration parameter writeProperty
.
The result is a single summary row, similar to stats
, but with some additional metrics.
The write
mode enables directly persisting the results to the database.
For more details on the write
mode in general, see Write.
CALL gds.modularityOptimization.write('myGraph', { relationshipWeightProperty: 'weight', writeProperty: 'community' })
YIELD nodes, communityCount, ranIterations, didConverge
nodes  communityCount  ranIterations  didConverge 

6 
2 
2 
true 
When using write
mode the procedure will return information about the algorithm execution.
In this example we return the number of processed nodes, the number of communities assigned to the nodes in the graph, the number of iterations and information whether the algorithm converged.
Running the algorithm without specifying the relationshipWeightProperty
will default all relationship weights to 1.0.
Mutate
The mutate
execution mode extends the stats
mode with an important side effect: updating the named graph with a new node property containing the community for that node.
The name of the new property is specified using the mandatory configuration parameter mutateProperty
.
The result is a single summary row, similar to stats
, but with some additional metrics.
The mutate
mode is especially useful when multiple algorithms are used in conjunction.
For more details on the mutate
mode in general, see Mutate.
CALL gds.modularityOptimization.mutate('myGraph', { relationshipWeightProperty: 'weight', mutateProperty: 'community' })
YIELD nodes, communityCount, ranIterations, didConverge
nodes  communityCount  ranIterations  didConverge 

6 
2 
2 
true 
When using mutate
mode the procedure will return information about the algorithm execution as in write
mode.