Configuring projections with unweighted relationships

Why Relationship Weights Matter

Not all connections are equal. In a user-movie rating network:

Rating scores provide natural relationship weights. When an algorithm like Leiden community detection uses these weights, it can detect communities of users who not only watched the same movies, but those who felt similarly about them.

Create Two Projections: Unweighted and Weighted

Let’s create a user-movie bipartite graph based on rating data. We’ll create two versions—one without weights and one with rating scores as weights.

First, drop any existing graphs using gds.graph.drop in the sandbox.

Create an unweighted user-movie projection called 'user-movie-unweighted':

Hint: For undirected relationships, place undirectedRelationshipTypes: ['*] inside the second set of curly brackets.

MATCH (source:User)-[r:RATED]->(target:Movie) // (1)
WITH gds.graph.project( // (2)
  'user-movie-unweighted', // (3)
  source, // (4)
  target, // (5)
  {}, // (6)
  {
    undirectedRelationshipTypes: ['*'] // (7)
  }
) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount // (8)

MATCH (source:User)-[r:RATED]->(target:Movie) // (1)
WITH gds.graph.project( // (2)
  'user-movie-weighted', // (3)
  source, // (4)
  target, // (5)
  {
    relationshipProperties: r { .rating } // (6)
  },
  {
    undirectedRelationshipTypes: ['*'] // (7)
  }
) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount // (8)

Leiden: Comparing Unweighted vs Weighted

Leiden detects communities by finding groups of nodes more densely connected to each other than to the rest of the network.

It is similar to Louvain. However, whereas Louvain tends to create giant components like this:

Leiden excels at breaking those larger components down into smaller, more granular cluster like this:

Let’s run Leiden on both projections using stats mode to compare the community structures.

First, on the unweighted graph:

CALL gds.leiden.stats('user-movie-unweighted', {}) // (1)
YIELD communityCount, modularity, modularities // (2)
RETURN communityCount, modularity, modularities // (3)

Now on the weighted graph:

CALL gds.leiden.stats('user-movie-weighted', { // (1)
  relationshipWeightProperty: 'rating' // (2)
})
YIELD communityCount, modularity, modularities // (3)
RETURN communityCount, modularity, modularities // (4)

Understanding the stats output:

The stats mode gives us summary statistics about the community structure:

Comparing the results:

Your unweighted graph likely returned with:

This groups users and movies based on rating strength—higher ratings create stronger connections.

Compare the community counts. The weighted version often produces more nuanced communities because it considers how much users liked movies, not just that they watched them.

Understanding Weighted Communities

Let’s examine what’s actually in these communities. First, the unweighted version:

CALL gds.leiden.stream('user-movie-unweighted', {}) // (1)
YIELD nodeId, communityId // (2)
WITH communityId, COLLECT(CASE WHEN 'User' IN labels(gds.util.asNode(nodeId)) THEN gds.util.asNode(nodeId).name END) AS users, COLLECT(CASE WHEN 'Movie' IN labels(gds.util.asNode(nodeId)) THEN gds.util.asNode(nodeId).title END) AS movies // (3)
WHERE size(users) > 0 AND size(movies) > 0 // (4)
RETURN communityId, size(users) AS userCount, size(movies) AS movieCount, users[0..3] AS sampleUsers, movies[0..3] AS sampleMovies // (5)
ORDER BY userCount + movieCount DESC // (6)
LIMIT 5 // (7)

These communities group users who rated similar movies—regardless of whether they loved or hated them.

Now the weighted version:

CALL gds.leiden.stream('user-movie-weighted', { // (1)
  relationshipWeightProperty: 'rating' // (2)
})
YIELD nodeId, communityId // (3)
WITH communityId, COLLECT(CASE WHEN 'User' IN labels(gds.util.asNode(nodeId)) THEN gds.util.asNode(nodeId).name END) AS users, COLLECT(CASE WHEN 'Movie' IN labels(gds.util.asNode(nodeId)) THEN gds.util.asNode(nodeId).title END) AS movies // (4)
WHERE size(users) > 0 AND size(movies) > 0 // (5)
RETURN communityId, size(users) AS userCount, size(movies) AS movieCount, users[0..3] AS sampleUsers, movies[0..3] AS sampleMovies // (6)
ORDER BY userCount + movieCount DESC // (7)
LIMIT 5 // (8)

These communities group users who gave similar ratings to similar movies—they not only watched the same things, but felt similarly about them.

Scroll through the communities and compare the outputs from both. Certain anomalous movies from the unweighted graph, have likely been replaced by more appropriate movies in weighted version.

When to Use Weighted Relationships

Use relationship weights when:

Examples of useful weights in different domains:

Weights transform your analysis from "what’s connected" to "how strongly it’s connected."

What’s next

You’ve seen how relationship orientation and weights affect algorithm results.

In the next lesson, you’ll put this knowledge to the test with a challenge: projecting a weighted graph and analyzing it using Label Propagation, a community detection algorithm you’ll explore through the GDS documentation.