Les graphiques avec R

Nous commençons cette fois-ci une série sur l’utilisation de graphiques sous R.

Je n’évoquerai pas les libraires “standards” (graphics par exemple) faisant partie des packages de base de R car il est fort probable que vous ne les utilisiez jamais après avoir connu ggplot2. De même je n’aborderai pas (tout du moins dans cette série), d’autres libraires telles que networkD3 qui ont des utilisations bien spécifiques.

Avant propos

Cet article va nous faire découvrir de façon directe la librairie et son fonctionnement afin d’être rapidement efficaces.

Puis dans la suite des articles, nous discuterons de la pertinence des différents types de graphiques avant d’attaquer l’étude des nombreuses variations possibles avec ggplot2.

ggplot2

ggplot2 est la librairie de graphiques du tidyverse (pour ne pas changer).

Comme d’habitude, elle s’installe soit par l’interface graphique de RStudio, soit dans la console de commande par un install.packages("ggplot2").

Et bien sûr il faudra la charger via un library(ggplot2).

La syntaxe

D’une façon assez similaire à dplyr, un graphique se crée par enchainement de fonctions.

L’opérateur utilisé est par contre le “+“. Il est courant de présenter le code à raison de maximum 1 graphique ou élément de paramétrage par ligne.

Traçons notre premier graphique et analysons le code :

f <- function(x) x + 2
g <- \(x) x ^ 2 - 4

ggplot() + 
  xlim(-10,10) +
  geom_function(fun = f)

Nous créons d’abord 2 fonctions (ce qui me permet de vous introduire la présentation abrégée de function() : \(). Je vous conseille cependant de l’utiliser avec parcimonie car elle rend le code beaucoup moins lisible. Pour ma part, je la réserve, comme ici, à la définition de fonctions purement mathématiques).

ggplot() crée le plan de dessin. Vous pouvez retrouver vos graphiques dans la fenêtre inférieure droite de RStudio. Un ggplot() isolé crée un espace vierge :

puis nous ajoutons des limites sur l’axe x avec la fonction xlim() (notez que nous n’avons pas fixé de limite en y donc il n’y a pas de graduation) :

puis nous ajoutons le tracé (une géométrie) de notre fonction f(x)sur l’ensemble de notre plage de données :

On note que l’échelle de l’axe y c’est adaptée aux données.

Une fois ce graphique réalisé, on peut en superposer d’autres en rajoutant simplement autant de définitions de géométries que nécessaire :

ggplot() +  
  xlim(-10, 10) +
  geom_function(fun = f) +
  geom_function(fun = g) 

Et voilà ! (bon ok ca n’est pas très beau ni très utile mais c’était pour illustrer…)

Le principe de ggplot

Les données

Dans l’exemple ci-dessus, il n’y avait pas de données mais le tracé d’une fonction. Cependant, nous travaillons généralement plutôt sur des données ou des échantillons. Pour la suite de l’article nous allons créer une table pour y ranger des données aléatoires respectant une distribution normale centrée sur 0, avec un écart type de 1 (réglages par défaut de rnorm()):

 datas <- data_frame(x = rnorm(10000),
                     y = rnorm(10000),
                     z = rnorm(10000))
> datas
# A tibble: 10,000 x 3
         x       y      z
     <dbl>   <dbl>  <dbl>
 1  0.590  -0.552  -1.61 
 2  0.349   0.0258  1.71 
 3  0.290  -1.26   -0.772
 4  0.733  -1.10    0.299
 5  1.56    0.289   0.561
 6 -0.884  -0.137  -0.236
 7  0.905  -0.811  -0.402
 8 -1.34   -1.73   -0.672
 9  1.64   -0.380  -0.537
10  0.0717 -1.75    1.67 
# ... with 9,990 more rows

Les esthétiques (aes())

Pour dessiner, ggplot a besoin de savoir quelles données tracer. Pour cela, on utilise des paramètres que l’on passe à une fonction de la famille geom_*.

Ces paramètres peuvent être attribués directement (on passe un vecteur de la même taille que les autres paramètres) ou tirés d’un dataframe passé en premier paramètre de la fonction (ou de ggplot pour le jeu par défaut). Ces données quand elles sont liées à un dataframe le sont via des esthétiques (aesthetics en anglais, d’où le non aes() de la sous-fonction).

Une esthétique permet donc de lier une donnée attendue par une geométrie de ggplot à un vecteur de données. Sur chaque page d’aide des fonctions de ggplot, vous trouverez la liste des paramètres esthétiques (pouvant donc être liés ou non à une donnée variable) et les paramètres non esthétiques (ne pouvant varier en fonction d’un jeu de données)

Si nous lisons par exemple la page d’aide de geom_point() nous trouvons :

> ? geom_point
<...>
Aesthetics
geom_point() understands the following aesthetics (required aesthetics are in bold):
x
y
alpha
colour
fill
group
shape
size
stroke

Ce qui veut dire que nous devons fournir obligatoirement x= et y= et pouvons spécifier les autres paramètres si cela nous est pertinent.

Nous pouvons alors dessiner notre nuage de point par exemple en faisant (x= sera x, y= sera y et la couleur color= variera de façon continue selon la valeur de z) :

ggplot(datas) +
  geom_point(aes(x = x, y = y, color = z), size = 3)

Comme vous pouvez le voir, l’aes() a permis d’aller chercher dans la table datas, les valeurs de x, y et z, par contre size= est réglé hors aes, il est donc constant pour la géométrie. A noter que dans notre exemple, datas est ajouté comme jeu de données par défaut dans le ggplot() mais qu’on pourrait tout à fait le préciser directement dans la géométrie par le paramètre nommé data=:

ggplot() +
  geom_point(data = datas, aes(x = x, y = y, color = z), size = 3)

Par ailleurs, certains paramètres de l’esthétique peuvent tout à fait ne pas être lié à un jeu de données mais être un “simple” vecteur, impérativement de la même taille que les autres. Ainsi on peut écrire :

ggplot(datas) +
  geom_point(aes(x = x, y = seq(1, 10000)),size = 3)

qui nous donne un graphique ou y croit de façon constante plutôt que d’être aléatoire :

Les couches

Comme nous l’avons vu plus haut, une couche de graphique est principalement définie par l’ajout d’une géométrie. Les types de couches principaux sont :

• Les graphiques proprement dits via les géométries (geom_*() ) ou les statistiques (stat_*() )
• Les manipulations de l’ensemble graphique permettant :
  • Le changement de repère, de gestion des systèmes de coordonnées ou d’échelles d’axes
  • La manipulation des échelles des esthétiques (scale_*())
  • Le facettage (facet_*())
  • Les éléments annexes (légendes, titres d’axes,..)
  • et d’autres réglages généraux…

Les géométries (geom_*)

Nous les aborderons plus en détail dans le prochain article. Mais pour ne pas vous laisser sur votre faim, en voici quelques unes les plus simples (en plus de geom_point() déjà vu plus haut) qui vont nous permettre de réaliser notre premier graphique de données multicouche.

Les lignes de construction

geom_abline() geom_hline() geom_vline() permettent de tracer des lignes respectivement en spécifiant la pente et l’interception de l’axe des y pour x = 0, horizontalement et verticalement.

Par exemple :

ggplot(datas) +  
  geom_vline(xintercept = c(max(datas$x), min(datas$x))) +
  geom_hline(yintercept = c(max(datas$y), min(datas$y))) +
  geom_abline(intercept = 2 , slope = 1)

nous permet de dessiner les limites min et max de nos données sur les 2 axes et de tracer une droite arbitraire.

xintercept, yintercept, etc peuvent de plus être des esthétiques. Par exemple, de notre jeu aléatoire, nous pouvons en tirer des sous groupes :

> datas2 <- datas %>% 
   mutate(sous_groupe = cut(x, c(-Inf, -1, 1, +Inf))

> datas2
# A tibble: 10,000 x 4
         x       y       z sous_groupe
     <dbl>   <dbl>   <dbl> <fct>      
 1  1.20    0.0884 -1.42   (1, Inf]   
 2 -0.596   0.820  -0.977  (-1,1]     
 3  0.753   0.537   0.166  (-1,1]     
 4  3.05    0.743   0.611  (1, Inf]   
 5  0.0301 -0.760   1.73   (-1,1]     
 6 -0.411   1.43   -0.0682 (-1,1]     
 7 -0.132  -1.27    0.353  (-1,1]     
 8 -0.332   0.133   0.0621 (-1,1]     
 9 -0.972   0.469  -0.232  (-1,1]     
10 -0.328   0.597   0.0295 (-1,1]     
# ... with 9,990 more rows

(une personne attentive remarquera que l’article ayant été écrit en plusieurs fois, les données aléatoires ont été régénérées et le contenu du tableau n’est plus le même… les aléas de faire cela en fonction sur le peu de temps de loisirs disponible…)

Et nous pouvons alors représenter graphiquement l’ensemble en points et la moyenne de chaque sous-groupe par un ligne verticale ainsi :

ggplot() + 
  geom_point(data = datas2,
             aes(x = x, 
                 y = y, 
                 color = sous_groupe)
  ) +
  geom_vline(data = datas2 %>%
                    group_by(sous_groupe) %>%
                    summarise(mx = mean(x)),
             aes(xintercept = mx, 
                 color = sous_groupe)
  )

Pour détailler :

• On crée un objet ggplot
• On y met une couche de points présents dans datas2 dont la couleur changera selon la valeur de la colonne sous_groupe nouvellement créée
• On superpose des lignes verticales dont l’abscisse est la moyenne des points de chaque sous-groupe calculé grâce au regroupement réalisé et passé dans le paramètre data=.

Ce qui nous donne :

A suivre

Nous nous arrêterons là pour cette fois-ci. L’article prochain, nous aborderons un autre sujet préliminaire qui n’est en lui-même pas spécifique à R mais capital : quel type de graphique utiliser selon les données à représenter ?

A bientôt !