Groupes Meetup à Rennes – Partie 3 (Neo4j)

Base exemple

Dans le précédent article, nous avions introduit le concept de représentation de données sous la forme d’un graphe avec cet exemple :

Si nous devions stocker ces informations dans une base de données SQL, nous pourrions utiliser le modèle physique suivant :

L’alimentation des tables s’effectuerait à l’aide de commandes SQL de type INSERT, ordonnées comme il se doit afin de respecter les diverses contraintes d’intégrité fonctionnelles qui régissent les connexions entre les tables.

Avec le langage de manipulation Cypher, la création et l’alimentation de notre base exemple s’effectue de la façon suivante :

CREATE
  (a:Personne {nom: 'Colin'}),
  (b:Personne {nom: 'Michel'}),
  (c:Personne {nom: 'Tristan'}),
  (d:Site {nom: 'Data-Bzh'}),
  (e:Activite {nom: 'Trail'}),
  (f:Auteur {nom: 'Proust'}),
  (g:Langage {nom: 'R'}),
  (a)-[:EST_CREATEUR]->(d),
  (a)-[:EST_CONTRIBUTEUR]->(d),
  (a)-[:LIT]->(f),
  (a)-[:PROGRAMME_EN]->(g),
  (b)-[:EST_CONTRIBUTEUR]->(d),
  (b)-[:PRATIQUE]->(e),
  (b)-[:PROGRAMME_EN]->(g),
  (c)-[:EST_CONTRIBUTEUR]->(d),
  (c)-[:PROGRAMME_EN]->(g);

La première partie du script créé les noeuds. La seconde créé les relations entre les noeuds.

On constate que la où SQL requiert de créer une structure (relativement figée) organisée autour de tables, puis de les alimenter, Neo4j ne nécessite aucun schéma préalable. Il suffit simplement de déclarer les noeuds et relations selon un formalisme très visuel similaire à du ASCII Art, avec une structure de type (noeud départ)-[:RELATION]->(noeud arrivée), les noeuds étant encadrés par des parenthèses, les relations par des crochets, le tout étant lié par des flèches, un peu comme ce que nous ferions si nous étions amenés à dessiner un schéma sur un tableau.

A noter que le noeuds peuvent-être regroupés par familles, grâce aux labels : (:Personne) représente un noeud avec le label “Personne”. Il est possible pour des noeuds de même label d’avoir des propriétés différentes, et pour un noeud d’avoir plusieurs labels.

Pour afficher l’ensemble des noeuds et relations, nous exécuterons la requête Cypher suivante :

MATCH (n) RETURN *;

Vous pouvez retrouver ce graphe sur la console en ligne de Neo4j : http://console.neo4j.org/r/l771u9.

Base Meetup

Pour la base Meetup, nous allons utiliser l’import à partir de fichiers délimités (format CSV).

Commençons par créer les noeuds :

// Création des groupes
// Fichier source : groups.nodes.tsv
// Structure : id, name, link, country, city, lon, lat, created, last_event
LOAD CSV WITH HEADERS
    FROM "file:///groups.nodes.tsv"
    AS row
    FIELDTERMINATOR '\t'
CREATE (:Group {id: toInteger(row.id), name: row.name, link:row.link, country:row.country, city:row.city, lon:toFloat(row.lon), lat:toFloat(row.lat), create:row.created, last_event:row.last_event});

// Création des thèmes
// Fichier source : topics.nodes.tsv
// Structure : id, name
LOAD CSV WITH HEADERS
    FROM "file:///topics.nodes.tsv"
    AS row
    FIELDTERMINATOR '\t'
CREATE (:Topic {id: toInteger(row.id), name: row.name});

// Création des membres
// Fichier source : members.nodes.tsv
// Structure : id, country, city, lon, lat
USING PERIODIC COMMIT 500
LOAD CSV WITH HEADERS
    FROM "file:///members.nodes.tsv"
    AS row
    FIELDTERMINATOR '\t'
CREATE (:Member {id: toInteger(row.id), country: row.country, city:row.city, lon:toFloat(row.lon), lat:toFloat(row.lat)});

Poursuivons avec la création des relations, qui permettront de connecter les différents noeuds :

// Relations entre groupes et thèmes
// Fichier source : topic_to_group.rel.tsv
// Structure : topic.id, group.id
USING PERIODIC COMMIT 500
LOAD CSV WITH HEADERS
    FROM "file:///topic_to_group.rel.tsv"
    AS row
    FIELDTERMINATOR '\t'
MATCH (t:Topic {id: toInteger(row.`topic.id`)})
MATCH (g:Group {id: toInteger(row.`group.id`)})
CREATE (g)-[:HAS_TOPIC]->(t);

// Relations entre groupes et membres
// Fichier source : member_to_group.rel.tsv
// Structure : group.id, member.id
USING PERIODIC COMMIT 500
LOAD CSV WITH HEADERS
    FROM "file:///member_to_group.rel.tsv"
    AS row
    FIELDTERMINATOR '\t'
MATCH (m:Member {id: toInteger(row.`member.id`)})
MATCH (g:Group {id: toInteger(row.`group.id`)})
CREATE (m)-[:IS_MEMBER]->(g);

La base de données graphe ainsi constituée a une taille d’environ 23 Mo.

Les requêtes suivantes permettent de retourner quelques informations complémentaires.

Nombre total de membres :

MATCH (n:Member) RETURN COUNT(n) AS MemberCount;

+-------------+
| MemberCount |
+-------------+
| 6611        |
+-------------+

Nombre total de groupes :

MATCH (g:Group) RETURN COUNT(g) AS GroupCount;

+------------+
| GroupCount |
+------------+
| 108        |
+------------+

Nombre total de thèmes :

MATCH (t:Topic) RETURN COUNT(t) AS TopicCount;

+------------+
| TopicCount |
+------------+
| 560        |
+------------+

Interrogation

Le tableau suivant expose quelques requêtes permettant de se familiariser un peu plus avec Cypher :

La saisie d’une requête depuis Neo4j Browser permet de bénéficier de l’auto-complétion et de la visualisation graphique du résultat :

Interrogation avec R

Le package R RNeo4j permet de manipuler les données Neo4j depuis notre environnement de prédilection.

La connexion au serveur s’effectue avec la fonction startGraph.

graph <- startGraph("http://localhost:7474/db/data/", username = Neo4jUser, password = Neo4JPassword)

Les requêtes Cypher sont exécutées avec les fonctions cypher ou cypherToList, selon que la requête retourne une structure tabulaire ou un sous-ensemble du graphe (composé de noeuds, relations ou chemins).

La requête suivante permet de récupérer (via la fonction cypher) les groupes ayant pour thème “Big Data” :

df <- cypher(graph, "MATCH (g:Group)-[:HAS_TOPIC]->(:Topic {name: 'Big Data'}) RETURN g.name, g.last_event")
names(df) <- c("name", "last_event")
df

La même requête avec la fonction cypherToList :

res <- cypherToList(graph, "MATCH (g:Group)-[:HAS_TOPIC]->(:Topic {name: 'Big Data'}) RETURN g")
df <- as.data.frame(t(sapply(res, function(i) { unlist(i$g) })))
df <- df[, c("name", "last_event")]
df

Le package expose aussi une API permettant de manipuler la base de données (création/modification de noeuds et de relations).

MATCH (g1:Group)<-[:IS_MEMBER]-(m:Member)-[:IS_MEMBER]->(g2:Group)
    WHERE g1 <> g2
WITH g1, g2, COUNT(m) AS w
MERGE (g1)-[:HAS_COMMON_MEMBERS {weight: w}]-(g2);

MATCH ()-[r:HAS_COMMON_MEMBERS]-() RETURN COUNT(r) AS GroupCommonCount;

+------------------+
| GroupCommonCount |
+------------------+
| 9516             |
+------------------+

WITH
    // Identifiant de la personne pour laquelle effectuer une recommandation
    133297112 AS Me
// 1. Groupes (g_reco) des membres (other) de mes (me) groupes (g_me)...
MATCH (me:Member {id: Me})-[:IS_MEMBER]->(g_me:Group)<-[:IS_MEMBER]-(other:Member)-[:IS_MEMBER]->(g_reco:Group)
WHERE
    // ... dont je ne suis pas membre.
    NOT (me)-[:IS_MEMBER]->(g_reco)
WITH
    // Groupes dont je ne suis pas membre 
    DISTINCT g_reco AS RecommendedGroups,
    // Nombre de membres en commun avec ce groupe
    COUNT(DISTINCT other) AS CommonMemberCount
    ORDER BY CommonMemberCount DESC
// 2. Noms des groupes recommandés, avec le nombre de membres en commun
RETURN
    RecommendedGroups.name,
    CommonMemberCount
LIMIT 10;

+------------------------------------------------------------------------------+
| RecommendedGroups.name                                   | CommonMemberCount |
+------------------------------------------------------------------------------+
| "UX Rennes"                                              | 670               |
| "Le Shift"                                               | 669               |
| "Agile Rennes"                                           | 636               |
| "La Cordée Rennes - partage, événements et bonne humeur" | 634               |
| "RennesJS"                                               | 545               |
| "Docker Rennes"                                          | 534               |
| "Osons le Leadership Rennes"                             | 424               |
| "EXPAIR - Applications Connectées et Intelligentes"      | 266               |
| "Crowdfunding GwenneG Meetup"                            | 236               |
| "Rennes Growth Hacking Meetup"                           | 230               |
+------------------------------------------------------------------------------+

WITH
    133297112 AS Me,
    "Communauté vidéo iPhone Bretagne" AS TargetGroupName
MATCH (me:Member {id: Me})-[:IS_MEMBER]->(g_me:Group)
MATCH path = shortestPath((g_me:Group)-[:HAS_COMMON_MEMBERS*]-(g_target:Group {name: TargetGroupName}))
RETURN me, path, length(path) AS RelCount
ORDER BY RelCount ASC
LIMIT 1;

WITH
    133297112 AS Me,
    "Communauté vidéo iPhone Bretagne" AS TargetGroupName,
    ["Meetup La French Tech Rennes St Malo"] AS ExcludeGroupNames
MATCH (me:Member {id: Me})-[:IS_MEMBER]->(g_me:Group)
WHERE NOT g_me.name IN ExcludeGroupNames
MATCH path = shortestPath((g_me:Group)-[:HAS_COMMON_MEMBERS*..3]-(g_target:Group {name: TargetGroupName}))
RETURN me, path, length(path) AS RelCount
ORDER BY RelCount ASC
LIMIT 1;