Neo4j Graph Data Science Training - June 9 & 10 - Slides #6 Graph Algorithms

Neo4j Graph Data Science
Graph Algorithms

● What are graph algorithms and how can we use them?
● Algorithms support tiers and execution modes
● Algorithm categories:
○ Centrality
○ Community detection
○ Similarity
○ Path ﬁnding
○ Link prediction
● Auxiliary procedures and utility functions
● Best Practices
2
Outline

Is an iterative analysis to make calculations that describe the
topology and connectivity of your graph
3
What are graph algorithms?
- Generally Unsupervised
- Global traversals & computations
- Learning overall structure
- Typically heuristics and
approximations
- Extracting new data from what you
already have

4
How can they be used?
Stand Alone Solution
Find signiﬁcant patterns and optimal
structures
Use community detection and
similarity scores for recommendations
Machine Learning Pipeline
Use the measures as features to train
an ML model
1st
node
2nd
node
Common
neighbors
Preferential
attachment
Label
1 2 4 15 1
3 4 7 12 1
5 6 1 1 0
4

Graph Algorithms Categories
5
Pathﬁnding
and Search
Centrality Community
Detection
Heuristic
Link Prediction
Similarity
Determines the
importance of
distinct nodes in the
network.
Detects group
clustering or
partition.
Evaluates how alike
nodes are by
neighbors and
relationships.
Finds optimal paths
or evaluates route
availability and
quality.
Estimates the
likelihood of nodes
forming a future
relationship.

6
Algorithms Per Category
• Parallel Breadth First Search &
Depth First Search
• Shortest Path
• Single-Source Shortest Path
• All Pairs Shortest Path
• Minimum Spanning Tree
• A* Shortest Path
• Yen’s K Shortest Path
• K-Spanning Tree (MST)
• Random Walk
• Degree Centrality
• Closeness Centrality
• CC Variations: Harmonic, Dangalchev,
Wasserman & Faust
• Betweenness Centrality
• Approximate Betweenness Centrality
• PageRank
• Personalized PageRank
• ArticleRank
• Eigenvector Centrality
• Triangle Count
• Clustering Coeﬃcients
• Weakly Connected Components
• Strongly Connected Components
• Label Propagation
• Louvain Modularity
• K1 coloring
• Modularity optimization
• Node Similarity
• Euclidean Distance
• Cosine Similarity
• Jaccard Similarity
• Overlap Similarity
• Pearson Similarity
Pathﬁnding
& Search
Centrality /
Importance
Community
Detection
Similarity
Link
Prediction
• Adamic Adar
• Common Neighbors
• Preferential Attachment
• Resource Allocations
• Same Community
• Total Neighbors
...and also:
• Random graph generation
• One hot encoding

Product supported: Supported by product engineering, tested for
stability, scale, fully optimized
CALL gds.<algorithm>.<execution-mode>[.<estimate>]
Beta: Candidate for product supported tier
CALL gds.beta.<algorithm>.<execution-mode>[.<estimate>]
Alpha: Experimental implementation, may be changed or removed at
any time.
CALL gds.alpha.<algorithm>.<execution-mode>[.<estimate>]
7
Tiers of Support
CALL gds[.<tier>].<algorithm>.<execution-mode>[.<estimate>](
graphName: STRING,
configuration: MAP
)

8
Execution Modes
Stream: Stream your results back as Cypher result rows. Generally node id(s) and
scores.
CALL gds[.<tier>].<algorithm>.stream[.<estimate>]
Write: Write your results back to Neo4j as node or relationship properties, or new
relationships. Must specify writeProperty
CALL gds[.<tier>].<algorithm>.write[.<estimate>]
Mutate: update the in-memory graph with the results of the algorithm
CALL gds[.<tier>].<algorithm>.mutate[.<estimate>]
Stats: Returns statistics about the algorithm output - percentiles, counts
CALL gds[.<tier>].<algorithm>.stats[.<estimate>]
graphName: STRING,
configuration: MAP
)

9
Estimation
Estimate lets you estimate the memory requirements for running your
algorithm with the speciﬁed conﬁguration -- just like .estimate with
graph catalog operations.
CALL gds.<algorithm>.<execution-mode>.estimate
Note: Only production quality algorithms support
.stats and .estimate
graphName: STRING,
configuration: MAP
)

Good news! All algorithms in GDS follow the same syntax:
10
Calling an Algorithm Procedure
graphName: STRING,
configuration: MAP
)

11
Common Conﬁguration Parameters
graphName: STRING,
configuration: MAP
)
Key Meaning Default
concurrency How many concurrent threads can be used when executing the algo? 4
readConcurrency How many concurrent threads can be used when reading data? concurrency
writeConcurrency How many concurrent threads can be used when writing results? concurrency
relationshipWeightProperty Property containing the weight (must be numeric) null
writeProperty Property name to write back to n/a

Determines the importance of
distinct nodes in the network.
Developed for distinct uses or
types of importance.
Centrality algorithms
13

14
Centrality Algorithms
Product supported:
- PageRank
Alpha implementations:
- ArticleRank
- Eigenvector Centrality
- Betweenness Centrality
- Closeness Centrality
- Degree Centrality

PageRank
What: Finds important nodes
based on their relationships
Why: Recommendations,
identifying inﬂuencers
Features:
- Tolerance
- Damping
15

Closeness Centrality:
Other Centrality Algorithms
19
Degree Centrality: Betweenness Centrality:
gds.alpha.betweenness
What: Calculated based on
how often a node acts as a
bridge on the shortest path
between nodes.
Why: Finding network
vulnerabilities, influence
gds.alpha.degree
the number of
relationships.
Why: Outlier identification,
preprocessing, influence
gds.alpha.closeness
average length of the
shortest path to all other
nodes.
Why: Diffusing information
quickly

Other Centrality Algorithms
20
Eigenvector Centrality: Harmonic Centrality:
gds.alpha.harmonic
What: Closeness centrality
variant, reverses sum and
reciprocal in formula
Why: Finding network
vulnerabilities, inﬂuence
gds.alpha.eigenvector
What: PageRank variant,
assumes connections to
highly connected nodes are
more important.
Why: Inﬂuence

Evaluates how a group is clustered
or partitioned.
Diﬀerent approaches to deﬁne a
community.
Community Detection Algorithms
22

23
Community Detection Algorithms
Product supported:
- Weakly Connected
Components (UnionFind)
- Label Propagation
- Louvain Modularity
- Strongly Connected
Components
- Triangle Counting &
Clustering Coeﬃcients
Beta implementations:
- K1 coloring
- Modularity optimization

Weakly Connected Components (WCC)
What: Finds disjoint subgraphs
in an undirected graph
Why: Graph preprocessing,
disambiguation
Features:
- Seeding
- Thresholds
- Consecutive identiﬁers
24

Louvain Modularity
What: Finds communities
Why: Useful for
recommendations, fraud
detection. Slower but produces
hierarchical results.
Features:
- Seeding
- Weighted relationships
- Intermediate communities
- Tolerance
- Max Levels, Max Iterations27

Label Propagation
What: Finds communities
Why: Useful for
recommendations, fraud
detection, ﬁnding common
co-occurrences. Very fast.
Features:
- Seeding
- Directed relationships
- Weighted relationships
30

Other community detection algorithms
32
K1 coloring: Strongly connected
components
Triangle count/
clustering coeﬃcient
gds.alpha.scc
What: Like weakly
connected components,
but includes directionality.
Why: Finding subgraphs,
preprocessing.
gds.beta.k1coloring
What: Find the approximate
minimum number of colors
so no two adjacent nodes
have the same color.
Why: Preprocessing,
scheduling optimization.
gds.alpha.triangleCount
What: Find the number of
triangles passing through
each node in the graph.
Why: Measuring graph
density, stability, and
cohesion.

Evaluates how alike nodes are at an
individual level either based on
node attributes, neighboring nodes,
or relationship properties.
Similarity Algorithms
34

35
Similarity Algorithms
Product supported:
- Node Similarity
- Jaccard
- Cosine
- Pearson
- Euclidean Distance
- Overlap
- Approximate Nearest
Neighbors

Node Similarity
What: Similarity between nodes
based on neighbors, intended
for bipartite graph. Writes new
relationships!
Why: Recommendations,
disambiguation
Features:
- topK
- topN
- Degree cutoﬀ
- Similarity cutoﬀ36

39
Other Similarity Algorithms
Node Based: These calculate
similarity based on common
neighbors
- Jaccard
- Overlap similarity
Approximate Nearest
Neighbors: This is a faster way
of building a similarity graph
than Jaccard -- minimizes the
number of comparisons
Relationship Based: These
calculate the similarity of
attributes on the same type of
relationship
- Pearson
- Euclidean distance
- Cosine similarity

40
Link Prediction Function:
Common Neighbors
What: The more number of
common neighbors between
two nodes, the higher the
likelihood for a new
relationship between them
Why: A high score predicts that
two nodes will form a
relationship in the future.
CALL db.relationshipTypes() YIELD
relationshipType as season
MATCH (n1:Character{name:'Daenerys'})
MATCH (n2:Character{name:'Jon'})
RETURN
gds.alpha.linkprediction.commonNeighbors(
n1, n2, {relationshipQuery:season}) AS
score
How likely Jon and Daenerys are going to
interact in various seasons?

Pathfinding and Graph Search
algorithms are used to identify
optimal routes, and they are often a
required first step for many other
types of analysis.
Pathfinding and Graph Search algorithms
42

44
Shortest Path
What: Using Dijkstra’s algorithm,
ﬁnd the shortest paths between
a source and target node
Why: Degrees of separation
between people, directions
between physical locations
Features:
- relationshipWeightProperty
What is the undirected shortest path between
Jon and Tywin?

45
Shortest Path
[‘Jon’], [‘Ned’], [‘Tywin’]
MATCH(start:Person{name:'Jon Snow'})
MATCH(end:Person{name:'Tywin Lannister'})
CALL gds.alpha.shortestPath.stream({
nodeProjection: Person,
relationshipProjection:{
INTERACTS_SEASON2: {
type: 'INTERACTS_2',
orientation: 'UNDIRECTED'
}},
startNode: start,
endNode: end
})
YIELD nodeId,cost
RETURN gds.util.asNode(nodeId).name AS
name,cost;

46
Yen’s K Shortest Paths
What: Using Dijkstra’s
algorithm, ﬁnd the k shortest
paths between a source and
target node
Why: Route availability,
assessing network redundancy
or resilience
Features:
- relationshipWeightProperty
- k (number of paths)
- path
What are the three shortest paths
between Jon and Tywin?

Yen’s K Shortest Paths Execution Call
47
MATCH(start:Person{name:'Jon Snow'}),
(end:Person{name:'Tywin Lannister'})
CALL gds.alpha.kShortestPaths.stream({
nodeProjection: 'Person',
orientation: 'UNDIRECTED',
properties:'weight'
}},
startNode: start,
endNode: end,
k: 3,
relationshipWeightProperty: 'weight',
path: true
})
YIELD path
RETURN path

48
Question
This syntax looks a little diﬀerent
than the other algorithms 🤔
Can you identify the major
diﬀerences?

49
We’re using an anonymous
graph instead of a pre-loaded
named graph
properties:'weight'
}},
startNode: start,
endNode: end,
k: 3,
path: true
})
YIELD path
RETURN path

50
You have to specify
the start and end
nodes -- ﬁrst
identifying them with
a Cypher MATCH
statement, then
referring to them in
the algo call
properties:'weight'
}},
startNode: start,
endNode: end,
k: 3,
path: true
})
YIELD path
RETURN path

51
This algorithm can
return a path, or paths,
if you set path to true!
properties:'weight'
}},
startNode: start,
endNode: end,
k: 3,
path: true
})
YIELD path
RETURN path

These methods compute a score for a pair of nodes,
where the score could be considered a measure of
proximity or “similarity” between those nodes based on
the graph topology.
Link Prediction
53

54
Link Prediction Functions
Link prediction algorithms are functions which
(1) take a pair of nodes as input and
(2) use a formula to calculate the probability that there should
be an edge between them
Where the available algorithms are: adamic adar, common
neighbors, preferential attachment, resource allocation, same
community, and total neighbors
MATCH (n1:Node {id:'id1'})
MATCH (n2:Node {id:'id2'})
RETURN gds.alpha.linkPrediction.<algoName>(n1,n2,
jjjjj{relationshipQuery:'relationshipType') AS score

55
Link Prediction Function:
Preferential Attachment
What: The better connected a
node is, the more likely it is to
form new edges (think: popular
people make more friends)
Why: A high preferential
attachment score predicts that
two nodes will form a
relationship in the future.
How likely Jon and
Daenerys are going
to interact in
various seasons?
CALL db.relationshipTypes() YIELD
relationshipType as season
MATCH (n1:Person{name:'Daenerys
Targaryen'})
MATCH (n2:Person{name:'Jon Snow'})
RETURN
gds.alpha.linkprediction.preferentialAttac
hment(n1, n2, {relationshipQuery:season})
AS score

56
Auxiliary Procedures &
Utility Functions

Auxiliary Procedures
57
Some procedures don’t quite ﬁt into the other categories… but are
still useful!
● Graph Generation: Make an in-memory graph with a set
number of nodes and relationships, which follow a speciﬁc
degree distribution.
CALL gds.beta.graph.generate
This lets you approximate a graph and estimate run times on
their hardware and set up.
● One hot encoding: Convert labels into vectors -- useful for ML
CALL gds.alpha.ml.oneHotEncoding

The GDS library includes a number of functions that help pre- and
post-process data to ﬁt into your cypher based workﬂows:
Pre-processing:
- gds.util.NaN
- gds.util.isFinite, gds.util.isInfinite
- gds.util.infinity
Post-processing:
- gds.util.asNode, gds.util.asNodes
- gds.util.asPath warning! this does not return a real path!
Helpers:
- gds.graph.exists
- gds.version58
Utility Functions

Neo4j Graph Data Science Training - June 9 & 10 - Slides #6 Graph Algorithms

Recommended

More Related Content

What's hot (20)

Similar to Neo4j Graph Data Science Training - June 9 & 10 - Slides #6 Graph Algorithms (20)

More from Neo4j (20)

Recently uploaded (20)

Neo4j Graph Data Science Training - June 9 & 10 - Slides #6 Graph Algorithms