如何使用 Python 在 Neo4j 中按权重在节点之间随机行走？

Question

我使用以下代码在 Neo4j 中创建了节点，from py2neo import Graph, Node, Relationshipg = Graph(password='neo4j')tx = g.begin()node1 = Node('Node', name='Node-1')node2 = Node('Node', name='Node-2')node3 = Node('Node', name='Node-3')node4 = Node('Node', name='Node-4')node5 = Node('Node', name='Node-5')node6 = Node('Node', name='Node-6')node7 = Node('Node', name='Node-7')tx.create(node1)tx.create(node2)tx.create(node3)tx.create(node4)tx.create(node5)tx.create(node6)tx.create(node7)rel12 = Relationship(node1, '0.2', node2, weight=0.2)rel13 = Relationship(node1, '0.2', node3, weight=0.2)rel14 = Relationship(node1, '0.6', node4, weight=0.6)rel45 = Relationship(node4, '0.5', node5, weight=0.5)rel46 = Relationship(node4, '0.3', node6, weight=0.3)rel47 = Relationship(node4, '0.2', node7, weight=0.2)tx.create(rel12)tx.create(rel13)tx.create(rel14)tx.create(rel45)tx.create(rel46)tx.create(rel47)tx.commit()这是界面中的图形Neo4j，我想按名称选择一个节点，然后随机走到另一个节点。但是随机选择应该是这样的，import randomrandom.choices(['Node-2', 'Node-3', 'Node-4'], weights=(0.2, 0.2, 0.6))我可以用下面的代码选择节点，但我不知道如何随机走到另一个节点。from py2neo import Graphfrom py2neo.matching import NodeMatcherg = Graph(password='neo4j')nodes = NodeMatcher(g)node1 = nodes.match('Node', name='Node-1').first()如果以node-1为起点，可以走的路，Node-1 -> Node-2Node-1 -> Node-3Node-1 -> Node-4 -> Node-5Node-1 -> Node-4 -> Node-6Node-1 -> Node-4 -> Node-7任何想法？提前致谢。

Answer 1

Py2neo 支持进行 Cypher 查询，这里有一个很好的 hello-world 教程，介绍如何做到这一点。

因此，我将提供一个带注释的 Cypher 查询，希望对您有用。

但首先，请注意几点：

• 您不应该为服务于相同目的的关系提供几乎无限数量的类型（如“0.2”、“0.5”等），因为当您想要按类型搜索特定关系时，这是非常无益的（这是其中之一你会想做的最常见的事情）并且会导致大量的关系类型。所以我在我的回答中假设利益关系实际上都有类型TO。

• 我的查询使用一个临时Temp节点来存储查询的临时状态，因为它遍历随机路径中的关系。该Temp节点将在查询结束时被删除。

查询如下：

// Get the (assumed-unique) starting Node `n` 

MATCH (n:Node)

WHERE n.name = 'Node-1'

// Create (if necessary) the unique `Temp` node, and initialize

// it with the native ID of the starting node and an empty `pathRels` list

MERGE (temp:Temp)

SET temp = {id: ID(n), pathRels: []}

WITH temp

// apoc.periodic.commit() repeatedly executes the query passed to it

// until it returns 0 or NULL.

// The query passed here iteratively extends the list of relationships

// in `temp.pathRels`. In each iteration, if the current `temp.id`

// node has any outgoing `TO` relationships, the query:

// - appends to `temp.pathRels` a randomly-selected relationship, taking

//   into account the relationship weights (which MUST sum to 1.0),

// - sets `temp.id` to the ID of the end node of that selected relationship,

// - and returns 1.

// But if the current `temp.id` node has no outgoing `TO` relationships, then

// the query returns 0.

CALL apoc.periodic.commit(

  "

    MATCH (a:Node)

    WHERE ID(a) = $temp.id

    WITH a, [(a)-[rel:TO]->() | rel] AS rels

    LIMIT 1 // apoc.periodic.commit requires a LIMIT clause. `LIMIT 1` should be harmless here.

    CALL apoc.do.when(

      SIZE(rels) > 0,

      '

       WITH temp, a, REDUCE(s={x: rand()}, r IN rels | CASE

         WHEN s.x IS NULL THEN s

         WHEN s.x < r.weight THEN {x: NULL, pathRel: r}

         ELSE {x: s.x - r.weight} END

       ).pathRel AS pathRel

       SET temp.id = ID(ENDNODE(pathRel)), temp.pathRels = temp.pathRels + pathRel

       RETURN 1 AS result

      ',

      '

       RETURN 0 AS result

      ',

      {temp: $temp, a: a, rels: rels}

    ) YIELD value

    RETURN value.result

  ",

  {temp: temp}

) YIELD batchErrors

// Use the `temp.pathRels` list to generate the `weightedRandomPath`

// (or you could just return `pathRels` as-is).

// Then delete the `Temp` node, since it is no longer needed.

// Finally, return `weightedRandomPath`, and also the `batchErrors` returned by

// apoc.periodic.commit() (in case it had any errors). 

WITH temp, apoc.path.create(STARTNODE(temp.pathRels[0]), temp.pathRels) AS weightedRandomPath, batchErrors

DELETE temp

RETURN weightedRandomPath, batchErrors