Configuring projections for undirected relationships

Solution

MATCH (source:Actor)-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(target:Actor) // (1)
WITH gds.graph.project( // (2)
  'actor-network-directed', // (3)
  source, // (4)
  target, // (5)
  {}, // (6)
  {} // (7)
) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount // (8)

Now let’s create an undirected version of the same projection called 'actor-network-undirected'.

We use the exact same Cypher pattern but add this configuration to the second set of curly brackets:

undirectedRelationshipTypes: ['*']

MATCH (source:Actor)-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(target:Actor) // (1)
WITH gds.graph.project( // (2)
  'actor-network-undirected', // (3)
  source, // (4)
  target, // (5)
  {}, // (6)
  {
    undirectedRelationshipTypes: ['*'] // (7)
  }
) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount // (8)

Understanding the configuration:

Both projections have the same nodes and relationships—only the orientation differs.

In the following sections, we’ll run two algorithms on both graphs to see how directionality can affect output.

Solution

CALL gds.pageRank.stream('actor-network-directed', {}) // (1)
YIELD nodeId, score // (2)
RETURN gds.util.asNode(nodeId).name AS actor, score // (3)
ORDER BY score DESC // (4)
LIMIT 10 // (5)

Now run the same query on the undirected graph ('actor-network-undirected'):

Solution

CALL gds.pageRank.stream('actor-network-undirected', {}) // (1)
YIELD nodeId, score // (2)
RETURN gds.util.asNode(nodeId).name AS actor, score // (3)
ORDER BY score DESC // (4)
LIMIT 10 // (5)

Compare the two result sets.

They should be identical — same as with degree centrality.

Despite this, there is a subtle difference. While degree centrality counts outgoing edges one-for-one from the node we’re ranking, PageRank counts them to the node we’re ranking and divides their weight by how many outgoing relationships the source nodes have given out.

In this case, Robert De Niro gets the highest score because he has the most authority in the collaboration network overall, not simply because he has the highest number of movies.

PageRank: Experimenting with dampingFactor

We can test this by playing around with the dampingFactor.

The dampingFactor controls how randomly the algorithm will jump around the graph vs how strictly it will follow links.

The dampingFactor provides a few benefits:

Move to the sandbox and run PageRank with different dampingFactor values on both graphs. Try values like 0.15, 0.50, 0.85, and 0.99.

Track how specific actors like Robert De Niro, Jackie Chan and Vincent Price move up and down the rankings as you change the configuration.

The default dampingFactor is 0.85. Normally, this provides a good mix of link-following vs random teleportation.

You can review all of the available config settings on the PageRank docs.

Compare PageRank on both graphs

Run PageRank with dampingFactor: 0.95 on both graphs and compare how orientation affects the rankings.

Remember to use stream mode and return the top 10 actors by score.

Solution

CALL gds.pageRank.stream('actor-network-directed', { // (1)
  dampingFactor: 0.95 // (2)
})
YIELD nodeId, score // (3)
RETURN gds.util.asNode(nodeId).name AS actor, score // (4)
ORDER BY score DESC // (5)
LIMIT 10 // (6)

CALL gds.pageRank.stream('actor-network-undirected', { // (1)
  dampingFactor: 0.95 // (2)
})
YIELD nodeId, score // (3)
RETURN gds.util.asNode(nodeId).name AS actor, score // (4)
ORDER BY score DESC // (5)
LIMIT 10 // (6)

Compare the two result sets, and they should be identical.

Key takeaway: Directionality did not affect the output, because our graph is already symetrical.

When we switch to undirected, we do not change the balance of the relationships.

What happened?

Run Leiden on undirected graph

Now run Leiden on the undirected graph ('actor-network-undirected'):

CALL gds.leiden.stream('actor-network-undirected', {}) // (1)
YIELD nodeId, communityId // (2)
WITH communityId, COUNT(*) AS size // (3)
RETURN communityId, size // (4)
ORDER BY size DESC // (5)
LIMIT 10 // (6)

Like Louvain, this shows community sizes. But Leiden tweaks the Louvain algorithm to produce more balanced, granular communities.

Key difference from PageRank: PageRank can adapt to both directed and undirected graphs, while Leiden has a hard requirement for undirected relationships.

You can find this out by referencing Leiden’s attributes header in the docs:

Leiden: Analyzing results

Let’s look at actors in the largest Leiden community.

Complete the query to stream Leiden results and return sample actors from the largest community:

CALL gds.leiden.stream('actor-network-undirected', {}) // (1)
YIELD nodeId, communityId // (2)
WITH communityId, collect(????) AS actors, count(*) AS size // (3)
ORDER BY size DESC // (4)
LIMIT 1 // (5)
RETURN communityId, size, actors[0..10] AS sampleActors // (6)

Solution

CALL gds.leiden.stream('actor-network-undirected', {}) // (1)
YIELD nodeId, communityId // (2)
WITH communityId, collect(gds.util.asNode(nodeId).name) AS actors, count(*) AS size // (3)
ORDER BY size DESC // (4)
LIMIT 1 // (5)
RETURN communityId, size, actors[0..10] AS sampleActors // (6)

Leiden: Custom configuration

Leiden also supports maxLevels like Louvain. Let’s experiment with different configurations.

Run Leiden with maxLevels: 1 to see how many communities it detects:

CALL gds.leiden.stats('actor-network-undirected', { // (1)
  maxLevels: 1 // (2)
})
YIELD communityCount, modularity, ranLevels // (3)
RETURN communityCount, modularity, ranLevels // (4)

Review the results for communityCount and ranLevels.

Now try with maxLevels: 20:

CALL gds.leiden.stats('actor-network-undirected', { // (1)
  maxLevels: 20 // (2)
})
YIELD communityCount, modularity, ranLevels // (3)
RETURN communityCount, modularity, ranLevels // (4)

The second run is unlikely to run to the full 20 levels.

While higher maxLevels allows for more granular community detection, like Louvain, Leiden will stop early if communities have already converged.

However, remember back when you ran Louvain on this graph. It returned around 1000+ communities.

Leiden should have returned many more than that — Leiden generally excels at producing more modular and granular communities than Louvain.