---
# System prepended metadata

title: TIW2 TP4

---

# TIW2 TP4

* Molinares Diogenes p2019196
* Bunel Maxime p1914012

#### 1. Inferer le schema

``` cypher
call db.schema();
```
![](https://i.imgur.com/esUAY7k.png)


#### 2. Quelle est la labelle la plus fréquente qui apparaît dans le jeux de données ?

Le label le plus courant est “Author” avec 80299 apparition 

``` cypher
MATCH (n) with labels(n) as title, count(*) as total 
order by total desc return * limit 1
```

#### 3. Quel est le nombre moyen d’articles publiés par un auteur ? 

Le nombre moyen d’article par auteur est d’environ 1.75

``` cypher
match (author:Author)-[:AUTHOR]-(article:Article) 
with author, count(*) as total 
return avg(total) as Average
```
#### 4. Quel est l’auteur qui a publié le plus? 

Peter G. Neumann est l’auteur qui à publié le plus avec 89 articles :

``` cypher
MATCH (a:Author)<-[:AUTHOR]-() 
RETURN a.name,count(a) 
order by count(a) desc limit 1
```

#### 5. Quel est l'année dans laquelle le plus de publications sont apparues ? 

L’année 2006 est celle pour laquelle le plus de publications sont apparues


``` cypher
MATCH (a:Article) 
return a.year, count(a.year) 
order by count(a.year) desc limit 1
```

#### 6. Un collaborateur potentiel Y d’un auteur X est une personne qui a publié avec un co-auteur Z de X, mais qui n’a pas publié directement avec X. Plus Y a publié avec Z, plus qu’il est un probable collaborateur futur de X. Écrire une requête pour trouver les 20 futurs collaborateurs les plus probables de Brian Fitzgerald. 

``` cypher
match (Y:Author)-[:AUTHOR]-(article:Article)-[:AUTHOR]-
(Z:Author)-[:AUTHOR]-(article2:Article)-
[:AUTHOR]-(X:Author{name:'Brian Fitzgerald'})
where X<>Y with X,Z,Y,count(Y) as total match (Y) 
where not (Y:Author)-[:AUTHOR]-(:Article)-[:AUTHOR]-(X:Author) 
return Z,Y,total order by total desc limit 20
```
![](https://i.imgur.com/nipB1ZC.png)


#### 7. Écrire une requête pour déterminer combien de ces collaborateurs les plus probables ont publié avec des collaborateurs de Brian plus de 3 fois ?

``` cypher
match (Y:Author)-[:AUTHOR]-(article:Article)-[:AUTHOR]-
(Z:Author)-[:AUTHOR]-(article2:Article)-[:AUTHOR]-(X:Author{name:'Brian Fitzgerald'})
where X<>Y with X,Z,Y,count(Y) as total match (Y) 
where not (Y:Author)-[:AUTHOR]-(:Article)-[:AUTHOR]-(X:Author) and total > 3 
return Z,Y,total order by total desc limit 20
```
![](https://i.imgur.com/iqV5OL2.png)


#### 8. Écrire une requête pour ajouter, à chaque node Article, le PageRank correspondant à son influence par rapport aux relations CITED. (N’oubliez pas que l’algorithme PageRank fait partie de la librairie Graph Data Science - plugin GDS - et que, donc, il faudrait ajouter gds quand on fait l’appel.)

``` cypher
call gds.graph.create('cited_rank','Article',{CITED:{}})
 
call gds.pageRank.stream('cited_rank') YIELD nodeId, score 
with gds.util.asNode(nodeId) as nod,score 
set nod.page_rank = score return nod
```

#### 9. Écrire une requête pour calculer les articles les plus influents par rapport à cette mesure PageRank. Renvoyer aussi le score associé à chaque article.

``` cypher
match (article:Article) return article.title, article.page_rank 
order by article.page_rank desc limit 207
```

#### 10. Écrire une requête pour trouver les auteurs qui ont publié le plus d’articles ‘open source’.

``` cypher
CALL db.index.fulltext.queryNodes("articles", "open source")
YIELD node, score
with ([(author)<-[:AUTHOR]-(node) | author.name]) AS authors
unwind authors as x
return x,count(x) order by count(x) desc
```

#### 11.Écrire un index de recherche pour la propriété name des nœuds avec le label Authors.

``` cypher
CALL db.index.fulltext.createNodeIndex('authors', ['Authors'], ['name'])
```

#### 12. Créer une relation CO_AUTHOR qui permet de relier chaque deux auteurs qui ont collaboré sur au moins un article. Ajouter une seule arête CO_AUTHOR même si la paire d’auteurs a collaboré sur plusieurs articles. Ajouter les propriétés suivantes a ces arêtes CO_AUTHOR : year : l'année de publication du premier article que les auteurs ont écrit ensemble. collaborations : le nombre d’articles sur lesquelles la paire d’auteurs a collaboré. 

``` cypher
match (a:Author)-[:AUTHOR]-(article)-[:AUTHOR]-(b:Author) 
with a,b,count(article) as collaboration,min(article.year) as years 
create (a)-[r:CO_AUTHOR {year: years, collaborations : collaboration}]->(b) 
return r
```
 
#### 13. Créer des nouvelles relations CO_AUTHOR_EARLY et CO_AUTHOR_LATE entre des nœuds correspondant à des co-auteurs qui ont été publiés ensemble avant, respectivement, après 2006.

``` cypher
match (author1:Author)-[a:CO_AUTHOR]-(author2:Author) 
where a.year>2006 create (author1)-[r:CO_AUTHOR_LATE]->(author2) return r

match (author1:Author)-[a:CO_AUTHOR]-(author2:Author) 
where a.year<2006 create (author1)-[r:CO_AUTHOR_EARLY]->(author2) return r
```
 
#### 14.Créer une projection en mémoire du graphe en exécutant la requête , Utiliser l’algorithme de comptage des triangles (cliques de trois nœuds), gds.alpha.triangleCount.write, sur la relation CO_AUTHOR_EARLY et, respectivement, sur la relation CO_AUTHOR_LATE. Interpréter les résultats. 

``` cypher
CALL gds.alpha.triangleCount.write('whole-graph', {
  writeProperty: 'triangles',
  relationshipTypes: ['CO_AUTHOR_EARLY']
})
YIELD triangleCount;

CALL gds.alpha.triangleCount.write('whole-graph', {
  writeProperty: 'triangles',
  relationshipTypes: ['CO_AUTHOR_LATE']
})
YIELD triangleCount;
```

Resultat : 
![](https://i.imgur.com/2jDG8Ye.png) ![](https://i.imgur.com/Hx2I0DU.png)
On remarque qu'il y eu plus de collaboration avant 2006 que après


#### 15. Utiliser l’algorithme de calcul des composantes connexes, gds.alpha.scc.write, sur la relation CITED pour calculer les différents clusters du graphe.


```cypher
CALL gds.alpha.scc.write({
  nodeProjection:'Article',
  writeProperty: 'componentId',
  relationshipProjection: {CITED: {orientation: "UNDIRECTED"}}
})
YIELD setCount, maxSetSize, minSetSize;
```


#### 16. Écrire une requête pour calculer quels sont les nœuds qui font partie de chaque composante.

```cypher
MATCH (a:Article) return a.componentId as ComponentID, collect(a.title) as Title
```

#### 17. Quelles sont les 3 composantes avec le plus de nœuds ? Écrire une requête permettant de les visualiser.

```cypher 
MATCH (a:Article)
RETURN a.componentId AS Component, count(*) AS ComponentSize
ORDER BY ComponentSize DESC
LIMIT 3
```



#### 18. Écrire une requête pour calculer, pour chaque composante, sa densité de publication (le nombre total d’articles publiés par les auteurs qui font partie de cette composante / le nombre total d’auteurs dans la composante). 

```cypher
MATCH (a:Article)-[:AUTHOR]-(author:Author) 
with a.componentId as ComponentID, author.name as Name, count(a) as Title 
return ComponentID, avg(Title) as densite order by densite desc
```



#### 19. Quelles sont les 3 composantes avec la plus forte densité ?

```cypher
MATCH (a:Article)-[:AUTHOR]-(author:Author) 
with a.componentId as ComponentID, author.name as Name, count(a) as Title 
return ComponentID, avg(Title) as densite order by densite desc LIMIT 3
```

#### 20. Ajouter une propriété weight = 1 sur les arêtes CO_AUTHOR et utiliser l’algorithme Louvain de détection de communautés pour identifier les clusters d’auteurs qui publient ensemble. Enregistrer la vitesse d'exécution de l’algorithme de clustering et la comparer avec celle correspondant au calcul des composantes connexes. Interpreter les resultats.

```cypher

MATCH (author1)-[r:CO_AUTHOR]->(author2)
SET r.weight=1;

CALL gds.louvain.write('whole-graph',{ 
nodeProjection : 'Author', 
relationshipProjection : 'CO_AUTHOR', 
writeProperty: 'community',
relationshipWeightProperty: 'weight' 
})
YIELD communityCount, modularity, modularities

```





