Decision Trees in Neo4j
Build dynamic expert systems and rules engines.

github.com/maxdemarzi
About 200 public repositories
Max De Marzi
Neo4j Field Engineer
About
Me !
01
02
03
04
maxdemarzi.com
@maxdemarzi

Let’s start with a Sign

Rule for Getting In
• Anyone over 21 years old gets in.
• On some nights, women 18 years or older get in.
• On some nights, men 18 years or older get in.
• The last two change dynamically.

Represent in a Graph

Rule Node
• expression (String):
• (age >= 18) && gender.equals(“female”)
• parameter_names(String):
• age, gender
• parameter_types(String):
• Int, String

There was a time…
BEFORE

When the Traversal API ruled supreme

https://maxdemarzi.com/2015/09/04/flight-search-with-the-neo4j-traversal-api/
Learn more… or read the docs

The Stored Procedure

@Procedure(name = "com.maxdemarzi.traverse.decision_tree", mode = Mode.READ)
@Description("CALL com.maxdemarzi.traverse.decision_tree(tree, facts)")
public Stream<PathResult> traverseDecisionTree(
@Name("tree") String id,
@Name("facts") Map<String, String> facts){
// Which Decision Tree are we interested in?
Node tree = db.findNode(Labels.Tree, "id", id);
if ( tree != null) {
// Find the paths by traversing this graph and the facts given
return decisionPath(tree, facts);
}
return null;
}
Tree Facts

private Stream<PathResult> decisionPath(Node tree,
Map<String, String> facts) {
TraversalDescription myTraversal =
db.traversalDescription()
.depthFirst()
.expand(new DecisionTreeExpander(facts))
.evaluator(decisionTreeEvaluator);
return myTraversal
.traverse(tree)
.stream()
.map(PathResult::new);
}
Build a Traversal Description

public class DecisionTreeEvaluator implements PathEvaluator {
@Override
public Evaluation evaluate(Path path, BranchState branchState) {
// If we get to an Answer stop traversing, we found a valid path.
if (path.endNode().hasLabel(Labels.Answer)) {
return Evaluation.INCLUDE_AND_PRUNE;
} else {
// If not, continue down this path
// to see if there is anything else to find.
return Evaluation.EXCLUDE_AND_CONTINUE;
}
}
Build a Path Evaluator

public class DecisionTreeExpander implements PathExpander {
private Map<String, String> facts;
private ExpressionEvaluator ee = new ExpressionEvaluator();
public DecisionTreeExpander(Map<String, String> facts) {
this.facts = facts;
ee.setExpressionType(boolean.class);
}
Build a Path Expander

@Override
public Iterable<Relationship> expand(Path path, BranchState branchState) {
// If we get to an Answer stop traversing, we found a valid path.
if (path.endNode().hasLabel(Labels.Answer)) {
return Collections.emptyList();
}
// If we have Rules to evaluate, go do that.
if (path.endNode()
.hasRelationship(Direction.OUTGOING, RelationshipTypes.HAS)) {
return path.endNode()
.getRelationships(Direction.OUTGOING, RelationshipTypes.HAS);
}
The expand method

if (path.endNode().hasLabel(Labels.Rule)) {
try {
if (isTrue(path.endNode())) {
return path.endNode()
.getRelationships(Direction.OUTGOING,
RelationshipTypes.IS_TRUE);
} else {
return path.endNode()
.getRelationships(Direction.OUTGOING,
RelationshipTypes.IS_FALSE);
}
} catch (Exception e) {
// Could not continue this way!
return Collections.emptyList();
}
}
The expand method (cont.)

boolean isTrue(Node rule) throws Exception {
Map<String, Object> ruleProperties = rule.getAllProperties();
String[] parameterNames =
Magic.explode((String) ruleProperties
.get("parameter_names"));
Class<?>[] parameterTypes =
Magic.stringToTypes((String) ruleProperties
.get("parameter_types"));
The isTrue method

Object[] arguments = new Object[parameterNames.length];
for (int j = 0; j < parameterNames.length; ++j) {
arguments[j] = Magic.createObject(parameterTypes[j],
facts.get(parameterNames[j]));
}
ee.setParameters(parameterNames, parameterTypes);
ee.cook((String)ruleProperties.get("expression"));
return (boolean) ee.evaluate(arguments);
The isTrue method (cont.)

Running it

CREATE (tree:Tree { id: 'bar entrance' })
CREATE (over21_rule:Rule { parameter_names: 'age',
parameter_types:'int',
expression:'age >= 21' })
CREATE (gender_rule:Rule { parameter_names: 'age,gender',
parameter_types:'int,String',
expression:'(age >= 18) && gender.equals("female")' })
CREATE (answer_yes:Answer { id: 'yes'})
CREATE (answer_no:Answer { id: 'no'})
CREATE (tree)-[:HAS]->(over21_rule)
CREATE (over21_rule)-[:IS_TRUE]->(answer_yes)
CREATE (over21_rule)-[:IS_FALSE]->(gender_rule)
CREATE (gender_rule)-[:IS_TRUE]->(answer_yes)
CREATE (gender_rule)-[:IS_FALSE]->(answer_no)
Build the Tree

CALL com.maxdemarzi.traverse.decision_tree(
‘bar entrance', {gender:'male', age:'20'})
YIELD path
RETURN path;
Check the Facts
Male, 20 years old?

It’s alright…

CALL com.maxdemarzi.traverse.decision_tree(
‘bar entrance', {gender:'female', age:’19'})
YIELD path
RETURN path;
Female, 19 years old?
Check the Facts

OMG…

Learn More…

https://maxdemarzi.com/2018/01/14/dynamic-rule-based-decision-trees-in-neo4j/
Details:

What about multiple Options?

https://maxdemarzi.com/2018/01/26/dynamic-rule-based-decision-trees-in-neo4j-part-2/
There is a Part 2

Decision Streams
• Paper:
https://arxiv.org/pdf/1704.07657.pdf
• Authors:
Dmitry Ignatov and Andrey Ignatov
• Implementation:
https://github.com/aiff22/Decision-Stream

Thank you!