Part 16: Exploring Node Similarity Using the Node Similarity Algorithm in Neo4j

Using the Node Similarity Algorithm in Neo4j

In this blog post, we will dive into the concept of node similarity using the node similarity algorithm in Neo4j. Node similarity is a fundamental technique in graph analytics, allowing us to identify nodes that are similar based on their neighborhood structure. This can be particularly useful in various applications, such as finding similar users in a social network or identifying similar products in a recommendation system. Let's walk through the process step by step.

Step 1: Understanding the Node Similarity Algorithm

The node similarity algorithm computes the similarity between pairs of nodes in a graph based on their neighborhood structure. Essentially, it helps us find nodes that share similar connections or relationships with other nodes.

Step 2: Running the Node Similarity Algorithm

To compute node similarity, we will use the node similarity stream procedure. Here's the query we'll use:

CALL gds.nodeSimilarity.stream('routes')
YIELD node1, node2, similarity
WITH gds.util.asNode(node1) AS n1, gds.util.asNode(node2) AS n2, similarity
RETURN
    n1.iata AS iata,
    n1.city AS city,
    COLLECT({iata: n2.iata, city: n2.city, similarityScore: similarity}) AS similarAirports
ORDER BY city LIMIT 20;

Breaking Down the Query

1. Calling the Node Similarity Stream Procedure:

CALL gds.nodeSimilarity.stream('routes')
YIELD node1, node2, similarity

• This line calls the node similarity algorithm on the routes graph.

• YIELD node1, node2, similarity: Returns the IDs of two nodes being compared and their similarity score.

2. Processing the Results with WITH Clause:

WITH gds.util.asNode(node1) AS n1, gds.util.asNode(node2) AS n2, similarity

• This line processes the results by converting the node IDs to node references.

• gds.util.asNode(node1) AS n1: Converts the internal node ID to a node reference and aliases it as n1.

• gds.util.asNode(node2) AS n2: Converts the internal node ID to a node reference and aliases it as n2.

• Retains the similarity score.

3. Returning the Desired Information:

RETURN
    n1.iata AS iata,
    n1.city AS city,
    COLLECT({iata: n2.iata, city: n2.city, similarityScore: similarity}) AS similarAirports
ORDER BY city LIMIT 20;

• iata: The IATA code of the first node in the pair.

• city: The city of the first node in the pair.

• similarAirports: An object containing the IATA code, city, and similarity score of the most similar node.

• ORDER BY city LIMIT 20: Sorts the results by city and limits the output to the first 20 results.

Query Explanation

This query helps us identify nodes (airports) that are similar based on their neighborhood structure. By analyzing the similarity score, we can discover patterns and relationships within our graph. The results will list the most similar airports, providing insights into how these nodes are connected.

Step 3: Advanced Node Similarity: topN and bottomN

We can further refine our node similarity analysis by specifying parameters such as topK and topN. Here's another query that demonstrates this approach:

CALL gds.nodeSimilarity.stream(
    'routes',
    {
        topK: 1,
        topN: 10
    }
)
YIELD node1, node2, similarity
WITH gds.util.asNode(node1) AS n1, gds.util.asNode(node2) AS n2, similarity AS similarityScore
RETURN
    n1.iata AS iata,
    n1.city AS city,
    {iata: n2.iata, city: n2.city} AS similarAirport,
    similarityScore
ORDER BY city;

Breaking Down the Advanced Query

1. Calling the Node Similarity Stream Procedure with Parameters:

CALL gds.nodeSimilarity.stream(
    'routes',
    {
        topK: 1,
        topN: 10
    }
)
YIELD node1, node2, similarity

• This line calls the node similarity algorithm on the routes graph with specific parameters.

• topK: 1: Specifies that for each node, we want to find the top 1 most similar node.

• topN: 10: Specifies that we want to consider the top 10 most similar nodes overall.

2. Processing the Results with WITH Clause:

WITH gds.util.asNode(node1) AS n1, gds.util.asNode(node2) AS n2, similarity AS similarityScore

• This line processes the results by converting the node IDs to node references.

• Aliases the similarity score as similarityScore.

3. Returning the Desired Information:

RETURN
    n1.iata AS iata,
    n1.city AS city,
    {iata: n2.iata, city: n2.city} AS similarAirport,
    similarityScore
ORDER BY city;

• iata: The IATA code of the first node in the pair.

• city: The city of the first node in the pair.

• similarAirport: An object containing the IATA code and city of the most similar node.

• similarityScore: The similarity score between the two nodes.

• ORDER BY city: Sorts the results by city.

Query Explanation

This query helps us find the most similar airports in terms of their neighborhood structure by considering specific parameters. By specifying topK and topN, we can refine our analysis to focus on the most relevant nodes.

Conclusion

Node similarity using the node similarity algorithm in Neo4j is a powerful technique for identifying similar nodes based on their neighborhood structure. By following the steps outlined above, you can easily compute and analyze node similarity in your graph data. This analysis can reveal important patterns and relationships within your network, enabling you to make informed decisions based on the similarity of nodes.