Quantilille 2017 – Analyses quantitatives des données en SHS

Ce billet permet de récupérer la plupart des éléments utilisés lors du module Quantilille 2017 intitulé Analyses quantitatives des données en SHS : diversité et complémentarité.
Chacun des .zip téléchargeables comprend a minima un jeu de données, un script et une présentation. Les bibliographies des deux modules 2017 sont disponibles au format .pdf. Un grand merci à l’équipe d’organisation – toujours au top – et à l’ensemble des participantes et participants pour leur dynamisme et leur curiosité.

Programme

Continuer la lecture

RStudio : sa vie, son oeuvre, ses ressources

RStudio est un environnement de développement (IDE) conçu spécialement pour R, à ne pas confondre avec les interfaces graphiques (GUI) de type R commander qui proposent de travailler en cliquant et non en codant. C’est un logiciel récent – la première version date de 2011 – qui a progressivement transformé la façon d’utiliser R. De nombreux utilisateurs ont du mal à imaginer le travail sur R sans cet IDE. L’équipe de RStudio s’est étoffée au cours du temps en intégrant des poids lourds de la communauté R, Hadley Wickham en particulier.

Fonctionnalités de RStudio

RStudio se développe à un rythme soutenu, intégrant sans cesse de nouvelles fonctionnalités. Actuellement (version 98.1103), on peut souligner les fonctionnalités suivantes :

  • intégration du code et du texte (dynamic documents) avec knitr : documents de type RMarkdown ou RSweave. Le document dynamique permet de faire un document tout-en-un incluant des contenus textuels, des blocs de code, des résultats numériques et des résultats graphiques. Plusieurs formats sont possibles : HTML, pdf ou docx. Ces développements récents sont liés à l’arrivée de Yihui Xie, créateur du package knitr, dans l’équipe de RStudio.
  • développement et appel de fonctions écrites en C++ dans R.
  • ensemble de raccourcis claviers très utiles pour cliquer le moins possible. La liste des raccourcis s’affiche en tapant Alt + Shift + k, ces raccourcis ne sont pas personnalisables pour le moment.
  • l’autocomplétion des noms d’objets avec la touche Tab, qui s’affine au cours du temps.
  • ensemble de fonctionnalités pour se repérer dans le code, pour y naviguer, pour rechercher, remplacer, sourcer, etc.
  • création et gestion de projets (RProj) permettant de sauver et de récupérer à chaque session l’espace de travail corespondant au projet. La gestion des répertoires avec setwd() et getwd()n’est plus nécessaire lorsqu’on travaille avec un projet, le chemin (path) vers les fichiers commence là où se trouve le fichier RProj.
  • création de packages : RStudio inclut maintenant plusieurs aides à la création de packages. Lorsqu’on crée un fichier projet (RProj), il faut déclarer qu’il s’agit d’un projet de package.
  • intégration de Git dans l’interface RStudio, pour travailler en contrôle de version avec Git et GitHub. Justement, le logiciel RStudio a été développé de façon collaborative sur la plateforme GitHub.

Autres produits développés par l’équipe RStudio

Le premier produit de l’équipe RStudio est l’IDE du même nom (RStudio Desktop). D’autres produits et services existent maintenant, en particulier RStudio Server à installer sur un serveur pour profiter des capacités de calcul et de mémoire supérieures aux ordinateurs de bureau ; et plusieurs projets liés au package shiny pour la conception d’applications interactives avec R, HTML et JavaScript (shiny server et shinyapps.io).

Ressources pour l’apprentissage

Enfin, RStudio propose un ensemble de ressources pour l’apprentissage :

Le logiciel RStudio est-il indispensable pour les utilisateurs de R ?

Certains utilisateurs viennent à R avec d’autres pratiques et d’autres éditeurs de code. Certains éditeurs de code sont très intéressants pour qui sait en tirer parti : Emacs, Sublime Text ou VIM (à noter : RStudio dispose d’un mode VIM à configurer dans les options). Ces utilisateurs ne verront pas forcément d’intérêt à changer d’éditeur de code s’ils sont expérimentés sur un éditeur performant.

En revanche, utiliser R dans son interface par défaut (sur Windows et sur Mac, sur Linux il n’y a pas d’interface par défaut) est inadmissible dans le sens de la notion d’admissibilité statistique : cette interface est plus mauvaise en tous points que l’IDE RStudio.

Pour répondre à la question : non, RStudio n’est pas indispensable mais en revanche il est indispensable de cesser d’utiliser l’interface par défaut de R.

L’analyse de réseaux avec R, les premiers pas (suite et fin)

Ce billet reprend un contenu publié sur le blog http://groupefmr.hypotheses.org/ en mai 2013.

L’objectif de ce billet est d’expliquer le plus simplement possible comment importer et transformer ses propres données et comment les visualiser. L’objectif de l’exercice est le suivant : importer un jeu de données comportant des attributs sur les liens et sur les sommets, puis de représenter le graphe en faisant dépendre la taille et la couleur des sommets de deux attributs et l’épaisseur des liens d’un troisième attribut.

Importer ses données

Les données proposées en exemple représentent un graphe fictif de relations entre enfants. Elles comportent deux fichiers : un fichier de type origine – destination – intensité concernant les liens non orientés existants, un fichier de type individus – variables qui précise les attributs de chacun des sommets (genre et âge). Pour télécharger le jeu de données et le script commenté dans ce billet, cliquer ici (les fichiers sont encodés en utf-8). En règle générale, avec R, il est préférable pour limiter les risques d’erreurs d’importer des fichiers de format texte (.txt ou .csv).

La démarche à suivre est la même avec les deux packages : mettre en forme ses données, les importer dans R puis les transformer en un objet que statnet et igraph sont capables d’analyser. Détail important : ces deux packages ne permettent pas d’analyser des graphes valués (i.e. l’intensité des liens n’est pas prise en compte pour le calcul des indicateurs) mais, dans la représentation graphique, il est possible de faire varier l’épaisseur des liens en fonction de leur intensité.

Une fois vos fichiers placés dans un dossier, créez dans ce même dossier un fichier script.txt et changez l’extension pour obtenir script.R. Ouvrez-le ensuite avec RStudio.

Le début du script est le suivant :

rm(list=ls())
l <- read.table(“liens.txt”, sep=”;”, header=TRUE)
s <- read.table(“sommets.txt”, sep=”;”, header=TRUE, stringsAsFactors=FALSE)

La première ligne supprime tout les objets précédemment créés dans R, les deux lignes suivantes permettent l’importation des fichiers. Il convient de préciser leur nom, le caractère utilisé pour séparer les colonnes (sep=””), éventuellement le caractère utilisé pour les décimales (dec=””) et header=TRUE informe R que la première ligne contient les étiquettes de colonnes. L’option stringsAsFactors permet d’éviter que R ne transforme les caractères de la variable qualitative GENRE en facteur. Une fois les fichiers importés, vous pouvez les visualiser en cliquant sur eux dans la fenêtre Workspace. Il est toujours prudent, surtout lorsque l’on débute avec R, mais la règle reste valable ensuite, de vérifier avant toute opération que l’importation s’est bien déroulée.

Avec igraph

La transformation des données est relativement simple avec igraph : la fonction graph.data.frame prend comme premier argument une liste de liens dont les deux premières colonnes doivent être les origines et les destinations. Les éventuelles colonnes supplémentaires seront considérées comme des attributs des liens. Les arguments suivants concernent la nature du graphe (orienté ou non notamment). Enfin, un argument vertices = permet d’importer les attributs des sommets. La ligne de code suivante permet donc de transformer nos deux fichiers en un objet igraph.

g <- graph.data.frame(l, directed=FALSE, vertices = s)

Pour la représentation, il faut d’abord définir les différents paramètres nécessaires et préciser les couleurs à utiliser, à quelle variable les attribuer, à quoi correspond la taille des sommets, l’épaisseur des liens etc. etc. Le code ci-dessous devrait vous donner la figure suivante – l’orientation des sommets pouvant être différente.

vertexCol <- get.vertex.attribute(g,”GENRE”)
colors = c(“Pink”,”Blue”)
vertexCol[vertexCol == “F”] = colors[1]
vertexCol[vertexCol == “M”] = colors[2]

vertexSiz <- get.vertex.attribute(g, “AGE”)

edgeW <- get.edge.attribute(g, “INT”)

plot(g, vertex.color= vertexCol, vertex.size = vertexSiz,
edge.width = edgeW)

Visualisation avec igraph

Avec statnet

La transformation en objet network analysable par statnet se fait à l’aide des commande as.matrix et as.network. Les noms sont explicites : as.matrix transforme une liste de liens en matrice ; as.network transforme la matrice en objet network. Donc, si vos données de départ sont au format matriciel, vous n’aurez pas besoin d’utiliser as.matrix… Dans la mesure où mes liens ne sont pas orientés, je le précise lors de la transformation avec l’option directed=FALSE. Je ne dois par contre prendre que les deux premières colonnes d’où les crochets et les parenthèses.

library(statnet)
ls <- as.network(as.matrix(l[,c(1:2)], directed=FALSE)
ls
gplot(ls)

La dernière étape consiste à transformer la dernière colonne du fichier l (intensité de la relation) et le fichier s (sommets) en données attributaires pour l’objet network ls créé à l’étape précédente. Cela se fait avec l’assignation %v% pour les sommets (v comme vertex) et %e% pour les liens (e comme edge).

ls %v% “GENRE” <- s$GENRE
ls %v% “AGE” <- s$AGE
ls %e% “int” <- l$INT

Pour la représentation graphique, il faut d’abord définir les couleurs à utiliser puis visualiser avec la fonction gplot. Cette fonction propose un très grand nombre d’options, le plus simple est de taper ?gplot puis de tester les différents scripts d’exemple. Bizarrement, il faut faire appel aux tableaux de départ et non à l’objet network pour personnaliser la visualisation. Les options utilisées ici sont les suivantes : gmode = “graph” signale que le graphe est non orienté ( = “digraph” dans le cas contraire) ; displaylabels permet d’afficher ou non les labels des sommets, vertex.col et vertex.cex permettent de choisir couleur et taille des sommets et enfin edge.lwd permet de moduler l’épaisseur des liens.

nodeColors <- ifelse(s$GENRE==”F”,”Pink”,”Blue”)

gplot(ls, gmode=”graph”, displaylabels=TRUE, vertex.col=nodeColors,
vertex.cex= s$AGE/4, edge.lwd = l$INT)

Le résultat obtenu ressemble – à l’orientation générale de la figure près – à ceci :

Visualisation avec statnet

En guise de conclusion

Le premier billet vous a – théoriquement – permis d’installer R, RStudio et de tester différente mesures de graphe à l’aide des packages statnet et igraph. Vous savez maintenant importer vos données (liens et attributs) et visualiser vos graphes en fonction des attributs importés, vous êtes donc quasi autonomes. Un dernier conseil pour finir : prenez toujours le temps de bien parcourir les rubriques d’aide des fonctions.

L’analyse de réseaux avec R, les premier pas

Ce billet reprend un contenu publié sur le blog http://groupefmr.hypotheses.org/ en avril 2013.

R est un logiciel libre, multiplateforme et qui permet de réaliser à peu près tous les traitements de données possibles dont, bien entendu, l’analyse de réseaux. Seul inconvénient, il fonctionne à l’aide de scripts et nécessite donc l’apprentissage d’un langage particulier. Pourquoi alors l’utiliser ? Parce qu’il s’agit d’un logiciel très puissant, qu’il permet de tout faire, et surtout parce que, une fois le langage maîtrisé, il permet de gagner un temps fou. Une fois le script écrit, obtenir toute une série de mesures sur un graphe prend quelques secondes alors que la même opération avec un logiciel presse boutons nécessite quelques dizaines de clics… Ce billet s’adresse aux personnes tentées par R mais qui n’osent pas encore franchir le pas.

La première partie explique comment installer R, l’interface RStudio (et son utilité), comment charger les modules (packages) d’analyse de réseaux et le fonctionnement de l’aide. La deuxième partie montre quelques manipulations basiques sur les graphes fournis en exemple avec les modules. Un second billet détaillera les procédures d’importation de ses propres données (sommets, liens et attributs) et les possibilités graphiques du logiciel (mise en ligne prévue pour fin avril).

Installer R et RStudio

Première étape : se rendre sur le site http://cran.r-project.org/ et télécharger la version de R compatible avec votre système d’exploitation. Puis se rendre sur le site http://www.rstudio.com/ et télécharger la dernière version de RStudio. RStudio est une interface graphique qui facilite l’utilisation de R en rendant un certain nombre de fonctions (rubriques d’aide, actualisation des modules etc.) beaucoup plus simples à utiliser. Elle n’est pas indispensable mais elle est fortement recommandée quand on débute avec R.

Une fois les deux logiciels téléchargés, installez-les (sous Windows, clic droit et exécuter en temps qu’administrateur). Les choix proposés par défaut sont généralement pertinents, vous pouvez donc les laisser. Lancer ensuite RStudio et vous obtenez une fenêtre de ce type (la capture a été effectuée sous environnement Windows 7, RStudio version 0.97.336). Quatre fenêtres sont ouvertes : celle en haut à gauche accueille les scripts, c’est-à-dire la suite d’instructions que vous allez exécuter ; les résultats apparaîtront dans la fenêtre en bas à gauche appelée la console. La fenêtre en haut à droite liste les jeux de données utilisés et l’historique des manipulations effectuées. Enfin, la fenêtre en bas à droite héberge les rubriques d’aide, les sorties graphiques et la liste des packages installés.

Interface de RStudio

Charger un package

R est un logiciel modulaire. Certains modules sont inclus par défaut lors de l’installation du logiciel, d’autres plus spécifiques doivent être installés. Pour débuter en analyse de réseaux, deux modules sont indispensables : le package statnet (qui est en réalité un ensemble de packages dépendants les uns des autres) et le package igraph. D’autres packages existent et plusieurs billets de ce blog en présentent certains (voir les billets sur le module intergraph, le module bipartite, le module QuACN ou le module qgraph).

statnet et igraph sont des packages inclus dans la version de base de R mais ils ne sont pas actifs au démarrage. Il convient donc de les charger à l’aide des fonctions library(statnet) et library(igraph). Attention, mais j’y reviendrai pas la suite, ces deux packages ne peuvent pas fonctionner ensemble. Pour exécuter une fonction, deux possibilités existent : la taper directement dans la console puis taper Entrée ; la taper dans un script et taper Ctrl + Entrée pour l’exécuter. Le résultat est exactement le même. Mais tout l’intérêt de R est de créer des scripts (des suites de commandes) qui peuvent être sauvegardés (ce sont de simples fichiers texte ayant l’extension .R) et réutilisés ensuite. Une bonne habitude est donc, à l’ouverture de RStudio, de créer un nouveau script à l’aide des menus déroulants File > Create new R script. Le menu File permet de créer les scripts, de les sauvegarder à l’endroit de son choix, de les ouvrir etc.

Créer un script avec RStudio

Au fait, pourquoi deux packages ? statnet est développé par des sociologues férus de modèles statistiques (ERGM) ; igraph est développé par des physiciens et des informaticiens. On trouve dans les deux les mesures les plus communes en analyse de réseaux mais certaines ne sont proposées que dans l’un de ces deux packages. Par ailleurs, la simplicité des commandes et la clarté des résultats varie d’un package à l’autre. A titre personnel, l’importation des données attributaires me semble beaucoup plus simple avec igraph mais je préfère les visualisations proposées par statnet. Mais ceci est affaire de goût… Autre avantage d’utiliser deux packages, ce qu’on ne parvient pas à faire avec l’un, on réussit généralement à le faire avec l’autre.

Les rubriques d’aide

Dans RStudio, lorsque que vous chargez un package à l’aide de la commande library(nom_du_package), l’aide s’affiche dans un onglet de la fenêtre Help. Si vous avez besoin de savoir comment fonctionne une instruction, il suffit de la taper dans la console, de taper Ctrl + Entrée et la rubrique s’affiche alors dans la fenêtre Help. Quand les créateurs et/ou créatrices du package ont fait du bon boulot, vous trouvez une définition de la fonction, sa structure (éléments indispensables et optionnels), les éléments pris en entrée et ceux fournis en sortie et enfin un exemple d’utilisation. La rédaction de la documentation étant en grande partie normée, ces rubriques sont généralement de bonne qualité (mais en anglais évidemment…).

Aide d'igraph dans RStudio

Les rubriques d’aide sont – avec les forums et listes de diffusion consacrés à R – sont vos meilleurs alliés pour progresser rapidement. Lorsque que vous utilisez un package pour la première fois, prendre le temps de regarder les différentes fonctions, d’examiner les jeux de données disponibles, de tester les scripts d’exemple proposés vous fera gagner un temps précieux.

Mais il est temps d’entrer dans le vif du sujet… La suite du billet suppose que vous avez installé R et RStudio… et c’est tout.

Pour les deux packages, les manipulations proposées sont les suivantes : chargement d’un jeu de données, calcul de la densité du graphe, du nombre et de la taille des composantes connexes, et enfin calcul de deux mesures de centralités des sommets (degré et intermédiarité, soit en bon anglais degree et betweenness). Comme indiqué plus haut, les aspects liés à la visualisation et à l’importation de ses propres billets seront abordés dans un second billet.

Manipulations basiques avec statnet

Le petit texte qui suit est un script, c’est-à-dire une liste d’instructions. Les étapes sont toujours les mêmes : nettoyer l’espace de travail (rm = remove), charger le package, charger un jeu de données puis effectuer les opérations souhaitées sur ce jeu de données. Quand on débute (et même après), il est vivement conseillé de commenter ses scripts : il suffit de placer un croisillon (AltGr + 3 sur Windows, Maj + @ sur Mac). Et c’est bien un croisillon et non un dièse1…) et ce qui est tapé ensuite n’est pas pris en compte par le logiciel.

Plusieurs jeux de données sont fournis avec statnet et l’exemple proposé ici utilise le jeu de données nommé faux.magnolia.high. Ce graphe simule les liens d’amitiés sur un campus américain (pour obtenir plus d’informations, taper ?faux.magnolia.high dans la console, Entrée et les détails s’affichent dans la fenêtre Help).

rm(list=ls()) #supprimer tous les objets importés ou créés auparavant
library(statnet) #chargement du package statnet
data(“faux.magnolia.high”) #chargement du jeu de données
g <- faux.magnolia.high #attribution d’un nom court (facilite la saisie)
g #informations de base sur le graphe

Taper le nom de l’objet g permet d’obtenir les informations suivantes : nombre de sommets (vertices = 1461), caractéristiques du graphe (ici on apprend qu’il est non-orienté, non multiple, ne comprend pas de boucles et qu’il ne s’agit pas d’un hypergraphe : directed = FALSE hyper = FALSE loops = FALSE multiple = FALSE bipartite = FALSE). On apprend enfin qu’il comprend 974 liens et qu’il n’y a pas de données manquantes (total edges= 974 missing edges= 0 non-missing edges= 974). Dernier point, mais qui ne sera pas utilisé dans ce billet, l’existence d’attributs (sur les sommets et/ou les liens) est indiqué : chaque sommet comprend un nom et des indications portant sur le niveau scolaire, le genre et l’ethnie (Vertex attribute names: Grade Race Sex vertex.names).

gden(g) #calcul de la densité
component.dist(g) #nombre et compositions des composantes connexes

Cette dernière fonction crée trois objets différents : un objet membership qui précise pour chaque sommet la composante connexe à laquelle il appartient ; un objet csize (component size) qui donne la taille de chacune des composantes connexes ; un objet cdist qui décrit la distribution des tailles des composantes connexes. Si je souhaite utiliser ces résultats ensuite – et la remarque s’applique aux opérations suivantes – j’ai tout intérêt à créer un objet qui va stocker ces résultats et me permettre de les réutiliser ensuite. La procédure est simple, je fais précéder l’instruction d’un nom (prendre un nom explicite est recommandé) et du petit symbole <-, ce qui donne la ligne de commande suivante. Les résultats ne s’affichent pas dans la console mais sont stockés – et réutilisables – dans l’objet comp.connexe.

comp.connexe <- component.dist(g)
deg <- degree(g) #calcul des degrés
summary(deg) #informations sur les degrés (min, Q1, médiane, moyenne, Q3 et max)
bet <- betweenness(g) #calcul de la centralité d’intermédiarité
summary(bet) #informations sur la centralité d’intermédiarité
tab <- as.data.frame(cbind(g$vertex.names, deg, bet)) #création d’un tableau

Cette dernière ligne appelle un petit commentaire : je crée un tableau de données (as.data.frame) qui consiste à coller côte à côte 3 colonnes (cbind), ces 3 colonnes étant le nom des sommets (g$vertex.names), leur degré (deg) et leur centralité d’intermédiarité (bet). Cette étape n’est pas obligatoire mais on peut préférer stocker tous les résultats concernant les sommets dans un même tableau plutôt que de multiplier les objets à manipuler.

Manipulations basiques avec igraph

Le mini-script qui suit réplique la même suite d’opérations mais avec le package igraph (et avec un jeu de données différent, le fameux Zachary karate club dataset). Comme vous le verrez, les noms des fonctions se ressemblent parfois fortement. Mais, statnet et igraph ne pouvant être utilisés de façon simultanée, il convient tout d’abord de détacher le package statnet puis de charger le package igraph.

rm(list=ls()) #nettoyer l’espace de travail
detach(package:statnet) #détacher le package statnet
library(igraph) #charger le package igraph
library(igraphdata)#charger les jeux de données du package igraph
data(karate) #charger le jeu de données du Zachary karate club
g <- karate #lui donner un nom plus court
g #principales propriétés

Taper g donne le résultat suivant : IGRAPH U-W- 34 78 — Zachary’s karate club network + attr: name (g/c), Citation (g/c), Author (g/c), Faction (v/n), weight (e/n). Ce qui en termes compréhensibles se traduit de la manière suivante : le graphe est non-orienté (U undirected) et valué (W weighted), il comprend 34 sommets et 78 liens, son nom est Zachary’s karate club network et il comprend un certain nombre d’attributs : sur le graphe (g : nom, auteur et citation), sur les sommets (v comme vertex ) et sur les lien (e comme edge).

graph.density(g) #densité du graphe
comp.connexe <- clusters(g) # composantes connexes

La fonction clusters crée trois objets : un objet membership qui indique à quelle composante appartient chaque sommet ; un objet csize indiquant la taille des composantes connexes et enfin un objet no donnant le nombre de composantes connexes. Le graphe étant ici connexe, les résultats de cette commande sont d’un intérêt relatif.

deg <- degree(g) #degré des sommets
bet <- betweenness(g) #centralité d’intermédiarité
tab <- as.data.frame(cbind(deg, bet)) #création d’un tableau
head(tab,10) #examen des 10 premières lignes du tableau

Et c’est tout pour aujourd’hui… Dernier conseil pour finir : avec R, il est important de prendre son temps et d’examiner les problèmes de manière séquentielle. Si vous abordez R pour la première fois, vous ne pouvez pas en deux heures apprendre à importer vos données, à lancer et interpréter un modèle ERGM puis à produire une superbe visualisation. Mais, avec des recours réguliers aux rubriques d’aide, de petits scripts (abondamment commentés) que vous enrichissez au fur et à mesure (j’ai créé un tableau avec 2 indicateurs, il est facile d’en ajouter…), votre progression sera rapide et efficace.

Ressources en ligne

Ayant déjà souvent écrit sur l’analyse de réseaux avec R – et je ne compte pas m’arrêter là -, je me permets de renvoyer à ce billet publié il y a quelques mois.

1 Robin Cura est la personne qui m’a permis de comprendre l’étendue de mon ignorance sur cet aspect crucial. Et il a évidemment raison : ♯ est un dièse, # est un croisillon….