Tag: neo4j

Graph analysis is all about finding relationships. In this post I show how to compute graph density (a ratio of how well connected relationships in a graph are) using a Cypher query with Neo4j. This is a follow up to the earlier post: SPARQL Query for Graph Density Analysis.

Installing Neo4j Graph Database

In this example we launch Neo4j and enter Cypher commands into the web console…

Neo4j is a java application and requires OracleJDK 7 or OpenJDK 7 to be on your system.
Download the Community Edition of Neo4j. In my case I grabbed the Unix .tar.gz file and unzipped the files. Install on Windows may vary.
From command line and within the newlycreatedneo4j-community folder, start the database:
1. ```
bin/neo4j start
```
Use web console at: http://localhost:7474 – the top line of the page is a window for entering Cypher commands.
Load sample CSV data using a Cypher command – I cover this in a separate post here. Be sure the path to the file is the same on your system, matching where you saved the CSV files to.

Quick Visualization

Using the built-in Neo4j graph browser, you can easily see all your relationships as nodes and edges. For a query, return results that include all the objects:

MATCH (p:Person)
RETURN p

Compute Graph Density

Graph Density requires total number of nodes and total number of relationships/edges. We do them both separately, then pull them together at the end.

Compute the number of unique nodes in the graph

MATCH (p:Person)
RETURN count(p)

count(p)
21
Returned 1 row in 49 ms

This tells us that there are 21 people as Subjects in the graph. (I’m not sure how this differed from the 20 I had in my other post – perhaps part of the header from the CSV came in?)

Therefore, a maximum number of edges between all people would be 21² (we’ll use only 21×20 as a person might not link to themselves in this example).

Compute the number of edges in the graph

Here we only select subjects that are “Person” and only where they have a relationship called “HAS_FRIEND”.

(The “p:”, “r:” and “f:” prefixes act like the “?…” variables references in SPARQL – you set them to whatever you want as a pointer to the data returned from the MATCH statement.)

MATCH (p:Person)-[r:HAS_FRIEND]-(f:Person)
RETURN count(DISTINCT r)

count(DISTINCT r)
57

When we defined the data from CSV, we set up a relationship that I thought would be just one-way. But you can see, if you don’t provide the DISTINCT keyword, that you’ll get double the record counts, so I’m assuming it’s treating the relationships as bi-directional.

Total edges is 57. Do the quick math and see that the ratio is then:

57 / (21 x 20)
= 57 / 420
= 0.136...

Rolling it all together

We can do all this in a single query and get some nice readable results, even though the query looks a bit long. Note that I snuck in an extra “-1” to account for that stray record I didn’t account for.

MATCH (p:Person)-[r:HAS_FRIEND]-(f:Person) 
RETURN count(DISTINCT p) as nrNodes, 
 count(DISTINCT r) as nrEdges,
 count(DISTINCT r)/((count(DISTINCT p)-1) * (count(DISTINCT p) - 1.0)) AS graphDensity

nrNodes nrEdges graphDensity
21      57      0.1425

Challenge: Why did I get different results than in the SPARQL query example?

In the earlier post I had only 20 nodes, but in this one got 21. Can you explain why?

Future Post

What’s your favourite graph analytic? Let me know and I’ll try it out in the future post.

One of things I have planned is to do some further comparisons between graph analytics in SPARQLverse and other product like Neo4j but with large amounts of data instead of these tiny examples. What different results would you expect?

Graph Data File – Simple Graph Relations Example

I took my earlier sample data and dumbed it down to fit the normal paradigm of Neo4j – separate nodes and edges load files. I appreciated working with triples before as I didn’t have to pre-load all the nodes first, but that’s also a story for another day.

First, the nodes file looked like the following. Note, I thought I had to add the ID though I didn’t end up using it after all:

id,name 1,Chong 2,Lashaun 3,Roberta 4,Elin 5,Tameka 6,Rosalie 7,Noella 8,Elim 9,Mae 10,Fernando 11,Alan 12,Katrina 13,Kaitlyn 14,Zackary 15,Nana 16,Lamonica 17,Meggan 18,Fermina 19,Genevieve 20,Manual 21,Jolie

The second file was simply a list of “source” and “target” names – the graph relations – where the first person had the second person for a friend. (We handle them as unidirectional in this example.)

source,target Chong,Lashaun Chong,Roberta Chong,Elin Chong,Tameka Chong,Rosalie Chong,Noella Lashaun,Roberta Lashaun,Elin Lashaun,Tameka Roberta,Elin Roberta,Tameka Roberta,Rosalie Roberta,Noella Elim,Tameka Elim,Rosalie Elim,Noella Elim,Mae Elim,Fernando Elim,Alan Tameka,Katrina Tameka,Kaitlyn Rosalie,Alan Noella,Katrina Mae,Kaitlyn Mae,Zackary Mae,Nana Mae,Lamonica Fernando,Meggan Fernando,Fermina Fernando,Genevieve Fernando,Manual Fernando,Jolie Fernando,Chong Alan,Lashaun Alan,Roberta Alan,Elin Katrina,Tameka Katrina,Rosalie Kaitlyn,Noella Zackary,Fernando Zackary,Alan Nana,Katrina Nana,Kaitlyn Nana,Zackary Lamonica,Zackary Lamonica,Fernando Meggan,Zackary Meggan,Fernando Meggan,Jolie Fermina,Fernando Fermina,Jolie Fermina,Chong Genevieve,Lashaun Genevieve,Roberta Manual,Elin Manual,Tameka Jolie,Rosalie

Basic load example of a handful of relationships.

Loading CSV Relationships into Neo4j

To get the data into Neo4j I had to run two commands. But first I run a sort of “delete all” as I was doing lots of testing:

MATCH (n) WITH n LIMIT 10000 OPTIONAL MATCH (n)-[r]->() DELETE n,r;

Then load all the nodes, assigning each one to a Person entity and grabbing only the name property from the CSV:

LOAD CSV WITH HEADERS FROM "file:///Users/tyler/graph/friends_nodes.csv" AS nodes CREATE (p:Person { name: nodes.name })

And finally, load the edges/relationships to map persons -> to persons via a has_friend relationship:

LOAD CSV WITH HEADERS FROM "file:///Users/tyler/graph/friends_edges.csv" AS edges MATCH (a:Person { name: edges.source}) MATCH (b:Person { name: edges.target }) CREATE (a)-[:HAS_FRIEND]->(b);

The resulting load will say something like:

Created 57 relationships, returned 0 rows in 46 ms

More on exploring and analysing this in a future post. Tweet it or comment if you are interested in more along this line. Thanks for reading!

Neo4j Cypher Query for Graph Density Analysis