Leiden

有向

无向

异构节点

异构关系

加权关系

词汇表

有向: 有向特性。该算法在有向图上定义良好。
有向: 有向特性。该算法忽略图的方向。
有向: 有向特性。该算法不在有向图上运行。
无向: 无向特性。该算法在无向图上定义良好。
无向: 无向特性。该算法忽略图的无向性。
异构节点: 完全支持异构节点。该算法能够区分不同类型的节点。
异构节点: 允许异构节点。该算法对所有选定节点一视同仁，无论其标签如何。
异构关系: 完全支持异构关系。该算法能够区分不同类型的关系。
异构关系: 允许异构关系。该算法对所有选定关系一视同仁，无论其类型如何。
加权关系: 加权特性。该算法支持将关系属性用作权重，通过 relationshipWeightProperty 配置参数指定。
加权关系: 加权特性。该算法将每个关系视为同等重要，并忽略任何关系权重的值。

简介

Leiden 算法是一种用于在大规模网络中检测社区的算法。该算法将节点分离到不相交的社区中，以最大化每个社区的模块度分数。模块度量化了节点到社区分配的质量，即与随机网络中它们的连接程度相比，社区中节点的连接密度如何。

Leiden 算法是一种层次聚类算法，通过贪婪地优化模块度将社区递归合并为单个节点，并在浓缩图中重复此过程。它修改了 Louvain 算法，解决了其一些缺点，即 Louvain 发现的一些社区连接不佳的情况。这是通过定期随机将社区分解为连接良好的小社区来实现的。

有关此算法的更多信息，请参阅

V.A. Traag, L. Waltman 和 N.J. van Eck “从 Louvain 到 Leiden：确保连接良好的社区”

运行此算法需要足够的内存。在运行此算法之前，我们建议您阅读内存估算。

语法

本节介绍在每种执行模式下执行 Leiden 算法所使用的语法。我们将描述命名图语法的变体。要了解有关通用语法变体的更多信息，请参阅语法概述。

每种模式的 Leiden 语法

在命名图上以流模式运行 Leiden。

CALL gds.leiden.stream(
  graphName: String,
  configuration: Map
)
YIELD
  nodeId: Integer,
  communityId: Integer,
  intermediateCommunityIds: List of Integer

表 1. 参数
名称	类型	默认值	可选	描述
graphName	字符串	`不适用`	否	存储在目录中的图的名称。
configuration	Map	`{}`	是	算法特定和/或图筛选的配置。

表 2. 配置
名称	类型	默认值	可选	描述
nodeLabels	字符串列表	`['*']`	是	使用给定的节点标签筛选命名图。将包含具有任何给定标签的节点。
relationshipTypes	字符串列表	`['*']`	是	使用给定的关系类型筛选命名图。将包含具有任何给定类型的关系。
concurrency	整数	`4 ^[1]`	是	用于运行算法的并发线程数。
jobId	字符串	`内部生成`	是	可以提供一个 ID，以便更轻松地跟踪算法的进度。
logProgress	布尔值	`true`	是	如果禁用，进度百分比将不会被记录。
relationshipWeightProperty	字符串	`null`	是	用作权重的关系属性的名称。如果未指定，算法将以无权模式运行。
maxLevels	整数	`10`	是	图被聚类然后浓缩的最大层数。
gamma	浮点数	`1.0`	是	计算模块度时使用的分辨率参数。在内部，对于无权图，该值除以关系数量；否则，除以所有关系的权重总和。 ^[2]
theta	浮点数	`0.01`	是	控制将社区分解为较小社区时的随机性。
tolerance	浮点数	`0.0001`	是	迭代之间模块度的最小变化。如果模块度变化小于容差值，则结果被认为是稳定的，算法将返回。
includeIntermediateCommunities	布尔值	`false`	是	指示是否写入中间社区。如果设置为 false，则仅保留最终社区。
seedProperty	字符串	`不适用`	是	用于设置节点的初始社区。属性值必须是非负数。
minCommunitySize	整数	`0`	是	只返回社区大小大于或等于给定值的节点。
1. 在 GDS 会话中，默认值为可用处理器数量 2. 分辨率越高，社区越多；分辨率越低，社区越少。

表 3. 结果
名称	类型	描述
节点 ID	整数	节点 ID。
社区 ID	整数	最终层级的社区 ID。
中间社区 ID	整数列表	每个层级的社区 ID。如果 `includeIntermediateCommunities` 设置为 false，则为 `Null`。

在命名图上以统计模式运行 Leiden。

CALL gds.leiden.stats(
  graphName: String,
  configuration: Map
)
YIELD
  preProcessingMillis: Integer,
  computeMillis: Integer,
  postProcessingMillis: Integer,
  communityCount: Integer,
  ranLevels: Integer,
  modularity: Float,
  modularities: List of Float,
  nodeCount: Integer,
  didConverge: Boolean,
  communityDistribution: Map,
  configuration: Map

表 4. 参数
名称	类型	默认值	可选	描述
graphName	字符串	`不适用`	否	存储在目录中的图的名称。
configuration	Map	`{}`	是	算法特定和/或图筛选的配置。

表 5. 配置
名称	类型	默认值	可选	描述
nodeLabels	字符串列表	`['*']`	是	使用给定的节点标签筛选命名图。将包含具有任何给定标签的节点。
relationshipTypes	字符串列表	`['*']`	是	使用给定的关系类型筛选命名图。将包含具有任何给定类型的关系。
concurrency	整数	`4 ^[3]`	是	用于运行算法的并发线程数。
jobId	字符串	`内部生成`	是	可以提供一个 ID，以便更轻松地跟踪算法的进度。
logProgress	布尔值	`true`	是	如果禁用，进度百分比将不会被记录。
relationshipWeightProperty	字符串	`null`	是	用作权重的关系属性的名称。如果未指定，算法将以无权模式运行。
maxLevels	整数	`10`	是	图被聚类然后浓缩的最大层数。
gamma	浮点数	`1.0`	是	计算模块度时使用的分辨率参数。在内部，对于无权图，该值除以关系数量；否则，除以所有关系的权重总和。 ^[4]
theta	浮点数	`0.01`	是	控制将社区分解为较小社区时的随机性。
tolerance	浮点数	`0.0001`	是	迭代之间模块度的最小变化。如果模块度变化小于容差值，则结果被认为是稳定的，算法将返回。
includeIntermediateCommunities	布尔值	`false`	是	指示是否写入中间社区。如果设置为 false，则仅保留最终社区。
seedProperty	字符串	`不适用`	是	用于设置节点的初始社区。属性值必须是非负数。
3. 在 GDS 会话中，默认值为可用处理器数量 4. 分辨率越高，社区越多；分辨率越低，社区越少。

表 6. 结果
名称	类型	描述
预处理毫秒数	整数	预处理数据所需毫秒数。
计算毫秒数	整数	运行算法所需毫秒数。
后处理毫秒数	整数	计算百分位数和社区计数所需毫秒数。
社区计数	整数	找到的社区数量。
运行层级数	整数	算法实际运行的层级数。
模块度	浮点数	最终模块度分数。
模块度	浮点数列表	每个层级的模块度分数。
节点计数	整数	图中节点数量。
是否收敛	布尔值	指示算法是否收敛。
社区分布	Map	包含最后一层社区大小的最小值、最大值、平均值以及 p1、p5、p10、p25、p50、p75、p90、p95、p99 和 p999 百分位数值的 Map。
configuration	Map	用于运行算法的配置。

在命名图上以修改模式运行 Leiden。

CALL gds.leiden.mutate(
  graphName: String,
  configuration: Map
)
YIELD
  preProcessingMillis: Integer,
  computeMillis: Integer,
  mutateMillis: Integer,
  postProcessingMillis: Integer,
  communityCount: Integer,
  ranLevels: Integer,
  modularity: Float,
  modularities: List of Float,
  nodeCount: Integer,
  didConverge: Boolean,
  nodePropertiesWritten: Integer,
  communityDistribution: Map,
  configuration: Map

表 7. 参数
名称	类型	默认值	可选	描述
graphName	字符串	`不适用`	否	存储在目录中的图的名称。
configuration	Map	`{}`	是	算法特定和/或图筛选的配置。

表 8. 配置
名称	类型	默认值	可选	描述
mutateProperty	字符串	`不适用`	否	GDS 图中写入社区 ID 的节点属性。
nodeLabels	字符串列表	`['*']`	是	使用给定的节点标签筛选命名图。
relationshipTypes	字符串列表	`['*']`	是	使用给定的关系类型筛选命名图。
concurrency	整数	`4`	是	用于运行算法的并发线程数。
jobId	字符串	`内部生成`	是	可以提供一个 ID，以便更轻松地跟踪算法的进度。
relationshipWeightProperty	字符串	`null`	是	用作权重的关系属性的名称。如果未指定，算法将以无权模式运行。
maxLevels	整数	`10`	是	图被聚类然后浓缩的最大层数。
gamma	浮点数	`1.0`	是	计算模块度时使用的分辨率参数。在内部，对于无权图，该值除以关系数量；否则，除以所有关系的权重总和。 ^[5]
theta	浮点数	`0.01`	是	控制将社区分解为较小社区时的随机性。
tolerance	浮点数	`0.0001`	是	迭代之间模块度的最小变化。如果模块度变化小于容差值，则结果被认为是稳定的，算法将返回。
includeIntermediateCommunities	布尔值	`false`	是	指示是否写入中间社区。如果设置为 false，则仅保留最终社区。
seedProperty	字符串	`不适用`	是	用于设置节点的初始社区。属性值必须是非负数。
5. 分辨率越高，社区越多；分辨率越低，社区越少。

表 9. 结果
名称	类型	描述
预处理毫秒数	整数	预处理数据所需毫秒数。
计算毫秒数	整数	运行算法所需毫秒数。
修改毫秒数	整数	向投影图添加属性所需毫秒数。
后处理毫秒数	整数	计算百分位数和社区计数所需毫秒数。
社区计数	整数	找到的社区数量。
运行层级数	整数	算法实际运行的层级数。
模块度	浮点数	最终模块度分数。
模块度	浮点数列表	每个层级的模块度分数。
节点计数	整数	图中节点数量。
是否收敛	布尔值	指示算法是否收敛。
写入的节点属性数	整数	添加到投影图的属性数量。
社区分布	Map	包含最后一层社区大小的最小值、最大值、平均值以及 p1、p5、p10、p25、p50、p75、p90、p95、p99 和 p999 百分位数值的 Map。
configuration	Map	用于运行算法的配置。

在命名图上以写入模式运行 Leiden。

CALL gds.leiden.write(
  graphName: String,
  configuration: Map
)
YIELD
  preProcessingMillis: Integer,
  computeMillis: Integer,
  writeMillis: Integer,
  postProcessingMillis: Integer,
  communityCount: Integer,
  ranLevels: Integer,
  modularity: Float,
  modularities: List of Float,
  nodeCount: Integer,
  didConverge: Boolean,
  nodePropertiesWritten: Integer,
  communityDistribution: Map,
  configuration: Map

表 10. 参数
名称	类型	默认值	可选	描述
graphName	字符串	`不适用`	否	存储在目录中的图的名称。
configuration	Map	`{}`	是	算法特定和/或图筛选的配置。

表 11. 配置
名称	类型	默认值	可选	描述
nodeLabels	字符串列表	`['*']`	是	使用给定的节点标签筛选命名图。将包含具有任何给定标签的节点。
relationshipTypes	字符串列表	`['*']`	是	使用给定的关系类型筛选命名图。将包含具有任何给定类型的关系。
concurrency	整数	`4 ^[6]`	是	用于运行算法的并发线程数。
jobId	字符串	`内部生成`	是	可以提供一个 ID，以便更轻松地跟踪算法的进度。
logProgress	布尔值	`true`	是	如果禁用，进度百分比将不会被记录。
writeConcurrency	整数	`'concurrency' 的值`	是	用于将结果写入 Neo4j 的并发线程数。
writeProperty	字符串	`不适用`	否	Neo4j 数据库中写入社区 ID 的节点属性。
relationshipWeightProperty	字符串	`null`	是	用作权重的关系属性的名称。如果未指定，算法将以无权模式运行。
maxLevels	整数	`10`	是	图被聚类然后浓缩的最大层数。
gamma	浮点数	`1.0`	是	计算模块度时使用的分辨率参数。在内部，对于无权图，该值除以关系数量；否则，除以所有关系的权重总和。 ^[7]
theta	浮点数	`0.01`	是	控制将社区分解为较小社区时的随机性。
tolerance	浮点数	`0.0001`	是	迭代之间模块度的最小变化。如果模块度变化小于容差值，则结果被认为是稳定的，算法将返回。
includeIntermediateCommunities	布尔值	`false`	是	指示是否写入中间社区。如果设置为 false，则仅保留最终社区。
seedProperty	字符串	`不适用`	是	用于设置节点的初始社区。属性值必须是非负数。
minCommunitySize	整数	`0`	是	只有社区大小大于或等于给定值的社区 ID 才会写入 Neo4j。
6. 在 GDS 会话中，默认值为可用处理器数量 7. 分辨率越高，社区越多；分辨率越低，社区越少。

表 12. 结果
名称	类型	描述
预处理毫秒数	整数	预处理数据所需毫秒数。
计算毫秒数	整数	运行算法所需毫秒数。
写入毫秒数	整数	向投影图添加属性所需毫秒数。
后处理毫秒数	整数	计算百分位数和社区计数所需毫秒数。
社区计数	整数	找到的社区数量。
运行层级数	整数	算法实际运行的层级数。
模块度	浮点数	最终模块度分数。
模块度	浮点数列表	每个层级的模块度分数。
节点计数	整数	图中节点数量。
是否收敛	布尔值	指示算法是否收敛。
写入的节点属性数	整数	添加到 Neo4j 数据库的属性数量。
社区分布	Map	包含最后一层社区大小的最小值、最大值、平均值以及 p1、p5、p10、p25、p50、p75、p90、p95、p99 和 p999 百分位数值的 Map。
configuration	Map	用于运行算法的配置。

示例

以下所有示例都应在空数据库中运行。

示例通常使用 Cypher 投影。原生投影将在未来的版本中废弃。

在本节中，我们将展示在具体图上运行 Leiden 社区检测算法的示例。目的是说明结果是什么样子，并提供在实际设置中如何使用该算法的指南。我们将在一个由少数节点以特定模式连接的小型社交网络图上执行此操作。示例图如下所示

以下 Cypher 语句将在 Neo4j 数据库中创建示例图

CREATE
  (nAlice:User {name: 'Alice', seed: 42}),
  (nBridget:User {name: 'Bridget', seed: 42}),
  (nCharles:User {name: 'Charles', seed: 42}),
  (nDoug:User {name: 'Doug'}),
  (nMark:User {name: 'Mark'}),
  (nMichael:User {name: 'Michael'}),

  (nAlice)-[:LINK {weight: 1}]->(nBridget),
  (nAlice)-[:LINK {weight: 1}]->(nCharles),
  (nCharles)-[:LINK {weight: 1}]->(nBridget),

  (nAlice)-[:LINK {weight: 5}]->(nDoug),

  (nMark)-[:LINK {weight: 1}]->(nDoug),
  (nMark)-[:LINK {weight: 1}]->(nMichael),
  (nMichael)-[:LINK {weight: 1}]->(nMark);

该图具有两个紧密连接的 Users 集群。这些集群通过单个边连接。关系属性 weight 决定了节点之间每个相应关系的强度。

我们现在可以将图投影并存储在图目录中。我们加载 LINK 关系，并将其方向设置为 UNDIRECTED，因为这与 Leiden 算法配合最佳。

以下语句将投影图并将其存储在图目录中。

MATCH (source:User)-[r:LINK]->(target:User)
RETURN gds.graph.project(
  'myGraph',
  source,
  target,
  {
    sourceNodeProperties: source { .seed },
    targetNodeProperties: target { .seed },
    relationshipProperties: r { .weight }
  },
  { undirectedRelationshipTypes: ['*'] }
)

在以下示例中，我们将演示在此图上使用 Leiden 算法。

内存估算

首先，我们将使用 estimate 过程估算运行算法的成本。这可以在任何执行模式下完成。在此示例中，我们将使用 write 模式。估算算法有助于了解在图上运行算法对内存的影响。当您稍后实际以某种执行模式运行算法时，系统将执行估算。如果估算显示执行超出其内存限制的可能性非常高，则禁止执行。要了解更多信息，请参阅自动估算和执行阻止。

有关 estimate 的更多详细信息，请参阅内存估算。

以下将估算以写入模式运行算法所需的内存

CALL gds.leiden.write.estimate('myGraph', {writeProperty: 'communityId', randomSeed: 19})
YIELD nodeCount, relationshipCount, requiredMemory

表 13. 结果
节点计数	关系计数	所需内存
6	14	"[551 KiB ... 551 KiB]"

流

在 stream 执行模式下，算法返回每个节点的社区 ID。这使我们能够直接检查结果，或在 Cypher 中对其进行后处理，而不会产生任何副作用。

有关 stream 模式的更多详细信息，请参阅流。

以下将运行算法并流式传输结果

CALL gds.leiden.stream('myGraph', { randomSeed: 19 })
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY name ASC

表 14. 结果
名称	社区 ID
"Alice"	1
"Bridget"	1
"Charles"	1
"Doug"	5
"Mark"	5
"Michael"	5

我们对过程配置参数使用默认值。maxLevels 设置为 10，gamma、theta 参数分别设置为 1.0 和 0.01。

统计

在 stats 执行模式下，算法返回一行，其中包含算法结果的摘要。此执行模式没有任何副作用。通过检查 computeMillis 返回项来评估算法性能可能很有用。在下面的示例中，我们将省略返回时间。该过程的完整签名可以在语法部分找到。

有关 stats 模式的更多详细信息，请参阅统计。

以下将运行算法并以统计和测量值的形式返回结果

CALL gds.leiden.stats('myGraph', { randomSeed: 19 })
YIELD communityCount

表 15. 结果
社区计数
2

修改

mutate 执行模式扩展了 stats 模式，增加了一个重要的副作用：使用包含该节点社区 ID 的新节点属性更新命名图。新属性的名称使用强制配置参数 mutateProperty 指定。结果是与 stats 类似的单个摘要行，但包含一些额外的指标。当多个算法结合使用时，mutate 模式特别有用。

有关 mutate 模式的更多详细信息，请参阅修改。

以下将运行算法并将结果存储在 myGraph 中

CALL gds.leiden.mutate('myGraph', { mutateProperty: 'communityId', randomSeed: 19 })
YIELD communityCount

表 16. 结果
社区计数
2

在 mutate 模式下，过程只返回一行。结果包含元信息，例如识别出的社区数量。结果写入 GDS 内存图，而不是 Neo4j 数据库。

写入

write 执行模式扩展了 stats 模式，增加了一个重要的副作用：将每个节点的社区 ID 作为属性写入 Neo4j 数据库。新属性的名称使用强制配置参数 writeProperty 指定。结果是与 stats 类似的单个摘要行，但包含一些额外的指标。write 模式允许将结果直接持久化到数据库。

有关 write 模式的更多详细信息，请参阅写入。

以下将运行算法并将结果存储在 Neo4j 数据库中

CALL gds.leiden.write('myGraph', { writeProperty: 'communityId', randomSeed: 19 })
YIELD communityCount, nodePropertiesWritten

表 17. 结果
社区计数	写入的节点属性数
2	6

在 write 模式下，过程只返回一行。结果包含元信息，例如识别出的社区数量。结果写入 Neo4j 数据库，而不是 GDS 内存图。

加权

Leiden 算法也可以在加权图上运行，在计算模块度时考虑给定的关系权重。

以下将对加权图运行算法并流式传输结果

CALL gds.leiden.stream('myGraph', { relationshipWeightProperty: 'weight', randomSeed: 19 })
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY name ASC

表 18. 结果
名称	社区 ID
"Alice"	4
"Bridget"	1
"Charles"	1
"Doug"	4
"Mark"	5
"Michael"	5

使用加权关系，我们看到 Alice 和 Doug 形成了他们自己的社区，因为他们的连接比其他所有连接都强得多。

使用中间社区

如前所述，Leiden 是一种层次聚类算法。这意味着在每个聚类步骤之后，属于同一集群的所有节点都被简化为单个节点。同一集群节点之间的关系变为自关系，与其他集群节点的关系连接到集群代表。然后使用这个浓缩图运行下一级别的聚类。该过程重复进行，直到集群稳定。

为了演示这种迭代行为，我们需要构建一个更复杂的图。

CREATE (a:Node {name: 'a'})
CREATE (b:Node {name: 'b'})
CREATE (c:Node {name: 'c'})
CREATE (d:Node {name: 'd'})
CREATE (e:Node {name: 'e'})
CREATE (f:Node {name: 'f'})
CREATE (g:Node {name: 'g'})
CREATE (h:Node {name: 'h'})
CREATE (i:Node {name: 'i'})
CREATE (j:Node {name: 'j'})
CREATE (k:Node {name: 'k'})
CREATE (l:Node {name: 'l'})
CREATE (m:Node {name: 'm'})
CREATE (n:Node {name: 'n'})
CREATE (x:Node {name: 'x'})

CREATE (a)-[:TYPE]->(b)
CREATE (a)-[:TYPE]->(d)
CREATE (a)-[:TYPE]->(f)
CREATE (b)-[:TYPE]->(d)
CREATE (b)-[:TYPE]->(x)
CREATE (b)-[:TYPE]->(g)
CREATE (b)-[:TYPE]->(e)
CREATE (c)-[:TYPE]->(x)
CREATE (c)-[:TYPE]->(f)
CREATE (d)-[:TYPE]->(k)
CREATE (e)-[:TYPE]->(x)
CREATE (e)-[:TYPE]->(f)
CREATE (e)-[:TYPE]->(h)
CREATE (f)-[:TYPE]->(g)
CREATE (g)-[:TYPE]->(h)
CREATE (h)-[:TYPE]->(i)
CREATE (h)-[:TYPE]->(j)
CREATE (i)-[:TYPE]->(k)
CREATE (j)-[:TYPE]->(k)
CREATE (j)-[:TYPE]->(m)
CREATE (j)-[:TYPE]->(n)
CREATE (k)-[:TYPE]->(m)
CREATE (k)-[:TYPE]->(l)
CREATE (l)-[:TYPE]->(n)
CREATE (m)-[:TYPE]->(n);

以下语句将投影图并将其存储在图目录中。

MATCH (source:Node)
OPTIONAL MATCH (source)-[r:TYPE]->(target:Node)
RETURN gds.graph.project(
  'myGraph2',
  source,
  target,
  {},
  { undirectedRelationshipTypes: ['*'] }
)

流式中间社区

以下将运行算法并流式传输结果，包括中间社区

CALL gds.leiden.stream('myGraph2', {
  randomSeed: 23,
  includeIntermediateCommunities: true,
  concurrency: 1
})
YIELD nodeId, communityId, intermediateCommunityIds
RETURN gds.util.asNode(nodeId).name AS name, communityId, intermediateCommunityIds
ORDER BY name ASC

表 19. 结果
名称	社区 ID	中间社区 ID
"a"	4	[2, 4]
"b"	4	[2, 4]
"c"	5	[7, 5]
"d"	4	[2, 4]
"e"	5	[6, 5]
"f"	5	[7, 5]
"g"	5	[7, 5]
"h"	5	[11, 5]
"i"	5	[11, 5]
"j"	1	[12, 1]
"k"	1	[12, 1]
"l"	1	[12, 1]
"m"	1	[12, 1]
"n"	1	[12, 1]
"x"	5	[6, 5]

种子化

可以通过提供种子属性来增量运行 Louvain 算法。如果指定，种子属性将为加载节点的一个子集提供初始社区映射。算法将尝试保留种子社区 ID。

以下将运行算法并流式传输种子化图的结果

CALL gds.leiden.stream('myGraph', { seedProperty: 'seed' })
YIELD nodeId, communityId, intermediateCommunityIds
RETURN gds.util.asNode(nodeId).name AS name, communityId, intermediateCommunityIds
ORDER BY name ASC

表 20. 结果
名称	社区 ID	中间社区 ID
"Alice"	42	null
"Bridget"	42	null
"Charles"	42	null
"Doug"	45	null
"Mark"	45	null
"Michael"	45	null

可以看出，使用种子化图，节点 Alice 保留其初始社区 ID 42。其他社区已分配了一个新的社区 ID，该 ID 保证大于最大的种子化社区 ID。请注意，为了保留种子值，不能将 consecutiveIds 配置选项与种子化结合使用

修改中间社区

以下将运行算法并使用中间社区修改内存图

CALL gds.leiden.mutate('myGraph2', {
  mutateProperty: 'intermediateCommunities',
  randomSeed: 23,
  includeIntermediateCommunities: true,
  concurrency: 1
})
YIELD communityCount, modularity, modularities

表 21. 结果
社区计数	模块度	模块度
3	0.3624	[0.3296, 0.3624]

以下将从内存图流式传输修改后的属性

CALL gds.graph.nodeProperty.stream('myGraph2', 'intermediateCommunities')
YIELD nodeId, propertyValue
RETURN
  gds.util.asNode(nodeId).name AS name,
  toIntegerList(propertyValue) AS intermediateCommunities
ORDER BY name ASC

表 22. 结果
名称	中间社区
"a"	[2, 4]
"b"	[2, 4]
"c"	[7, 5]
"d"	[2, 4]
"e"	[6, 5]
"f"	[7, 5]
"g"	[7, 5]
"h"	[11, 5]
"i"	[11, 5]
"j"	[12, 1]
"k"	[12, 1]
"l"	[12, 1]
"m"	[12, 1]
"n"	[12, 1]
"x"	[6, 5]

写入中间社区

以下将运行算法并将中间社区写入 Neo4j 数据库

CALL gds.leiden.write('myGraph2', {
  writeProperty: 'intermediateCommunities',
  randomSeed: 19,
  includeIntermediateCommunities: true,
  concurrency: 1
})
YIELD communityCount, modularity, modularities

表 23. 结果
社区计数	模块度	模块度
3	0.3624	[0.3296, 0.3624]

以下将从 Neo4j 数据库流式传输写入的属性

MATCH (n:Node) RETURN n.name AS name, toIntegerList(n.intermediateCommunities) AS intermediateCommunities
ORDER BY name ASC

表 24. 结果
名称	中间社区
"a"	[2, 4]
"b"	[2, 4]
"c"	[7, 5]
"d"	[2, 4]
"e"	[6, 5]
"f"	[7, 5]
"g"	[7, 5]
"h"	[11, 5]
"i"	[11, 5]
"j"	[12, 1]
"k"	[12, 1]
"l"	[12, 1]
"m"	[12, 1]
"n"	[12, 1]
"x"	[6, 5]