Représentations graphiques

Auteur·rice

Elias Bouacida

Date de publication

15 octobre 2024

Introduction

Introduction

ggplot2 est une librairie qui permet de générer des graphiques avec une syntaxe cohérente et puissante. Elle nécessite l’apprentissage d’un “mini-langage” supplémentaire, mais permet la construction de graphiques complexes de manière efficace.

Une des particularités de ggplot2 est qu’elle part du principe que les données relatives à un graphique sont stockées dans un tableau de données (data.frame, tibble ou autre).

Ce chapitre est élaboré à partir du chapitre 8 de Barnier et Kauffmann (2023).

Préparation

ggplot2 est un paquet comme un autre, que l’on charge à l’aide de library

library(ggplot2)

Données

Les données que nous allons utiliser sont issues du recensement de la population de 2018 inclus dans le paquet questionr, que nous devons installer et charger.

install.packages('questionr')
library(questionr)

Nous allons seulement utiliser une partie de ces données, nous utilisons pour cela la fonction filter de la librairie tidyverse.

data(rp2018)

rp <- filter(
  rp2018,
  departement %in% c("Oise", "Rhône", "Hauts-de-Seine", "Lozère", "Bouches-du-Rhône")
)

Initialisation : données à représenter

Un graphique ggplot2 s’initialise à l’aide de la fonction ggplot(). Les données sont toujours issues d’un tableau de données, qu’on passe en argument data à la fonction ggplot.

ggplot(data = rp)
ggplot(rp) ## Equivalent au premier et généralement utilisé

Géométries : comment ?

Il faut ajouter des éléments de représentation graphique. Ces éléments sont appelés des geom et on les ajoute à l’objet graphique de base avec l’opérateur +.

Une des geom les plus simples est geom_histogram :

ggplot(rp) + geom_histogram()

Esthétiques : quelles données sont représentées ?

Reste à indiquer quelle donnée nous voulons représenter sous forme d’histogramme. Cela se fait à l’aide d’arguments passés via la fonction aes(). Ici, nous avons un paramètre à renseigner, x, qui indique la variable à représenter sur l’axe des x (l’axe horizontal).

Ainsi, si on souhaite représenter la distribution des communes du jeu de données selon le pourcentage de cadres dans leur population active (variable cadres) :

ggplot(rp) + geom_histogram(aes(x = cadres))
`stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

Si on veut représenter une autre variable, il suffit de changer la valeur de x :

ggplot(rp) + geom_histogram(aes(x = ouvr))
`stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

En résumé

Pour représenter un graphique, il faut :

  1. Des données (argument data de ggplot())
  2. Un type de représentation (histogramme, ligne, point, etc) donné par geom_xxxx où xxxx est le type de représentation recherché.
  3. Une ou des variables à représenter (argument aes() dans geom_xxxx)

On lie les différentes commandes à l’aide de l’opérateur +.

Les géométries

Nuage de points

Certaines geom prennent plusieurs paramètres. Ainsi, si on veut représenter un nuage de points, on peut le faire en ajoutant un geom_point. On doit alors indiquer à la fois la position en x (la variable sur l’axe horizontal) et en y (la variable sur l’axe vertical) de ces points, il faut donc passer ces deux arguments à aes() :

ggplot(rp) + geom_point(aes(x = dipl_sup, y = cadres))

Apparence des géométries

On peut modifier certains attributs graphiques d’un geom en lui passant des arguments supplémentaires. Par exemple, pour un nuage de points, on peut modifier :

  • la couleur avec l’argument color ;
  • la taille avec l’argument size ;
  • la transparence avec l’argument alpha.
ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres),
    color = "darkgreen", size = 3, alpha = 0.3
  )

On notera que dans ce cas les arguments sont dans la fonction geom mais à l’extérieur du aes(). Plus d’explications sur ce point dans quelques instants.

Exemples de geom

Il existe un grand nombre de geom, décrites en détail dans la documentation officielle. Outre les geom_histogram et geom_point que l’on vient de voir, on pourra noter les geom suivantes :

  • geom_boxplot
  • geom_violin
  • geom_bar et geom_col
  • geom_text
  • geom_label
  • geom_density
  • geom_line
  • geom_hex et geom_bin2d

Mappages

Un mappage, dans ggplot2, est une mise en relation entre un attribut graphique du geom (position, couleur, taille…) et une variable du tableau de données.

Ces mappages sont passés aux différents geom via la fonction aes().

Exemples de mappages

On a déjà vu les mappages x et y pour un nuage de points. Ceux-ci signifient que la position d’un point donné horizontalement (x) et verticalement (y) dépend de la valeur des variables passées comme arguments x et y dans aes().

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres)
  )

Couleur (color ou colour)

Il y en a d’autres. color permet de faire varier la couleur des points automatiquement en fonction des valeurs d’une troisième variable.

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres, color = departement)
  )

Tailles (size)

On peut aussi faire varier la taille des points avec size. Ici, la taille dépend de la population totale de la commune :

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres, color = departement, size = pop_tot)
  )

Transparence (alpha)

On peut même associer la transparence des points à une variable avec alpha :

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres, color = departement, size = pop_tot, alpha = maison)
  )

Chaque geom possède sa propre liste de mappages.

aes() or not aes() ?

Parfois on souhaite changer un attribut sans le relier à une variable : par exemple si on veut représenter tous les points en rouge. On utilise toujours l’attribut color, mais comme il ne s’agit pas d’un mappage, on le définit à l’extérieur de la fonction aes().

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres),
    color = "red"
  )

Par contre, si on veut faire varier la couleur en fonction des valeurs prises par une variable, on réalise un mappage, et on doit donc placer l’attribut color à l’intérieur de aes().

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres, color = departement)
  )

On peut mélanger attributs liés à une variable (mappage, donc dans aes()) et attributs constants (donc à l’extérieur). Dans l’exemple suivant, la taille varie en fonction de la variable pop_tot, mais la couleur est constante pour tous les points.

ggplot(rp) +
  geom_point(
    aes(x = dipl_sup, y = cadres, size = pop_tot),
    color = "royalblue"
  )

La règle est donc simple mais très importante :
Si on établit un lien entre les valeurs d’une variable et un attribut graphique, on définit un mappage, et on le déclare dans aes(). Sinon, on modifie l’attribut de la même manière pour tous les points, et on le définit en-dehors de la fonction aes().

Représentation de plusieurs geom

On peut représenter plusieurs geom simultanément sur un même graphique, il suffit de les ajouter à tour de rôle avec l’opérateur +.

Par exemple, on peut superposer la position des points au-dessus d’un boxplot. On va pour cela ajouter un geom_point après avoir ajouté notre geom_boxplot.

ggplot(rp) +
  geom_boxplot(aes(x = departement, y = maison)) +
  geom_point(
    aes(x = departement, y = maison),
    col = "red", alpha = 0.2
  )

Quand une commande ggplot2 devient longue, il peut être plus lisible de la répartir sur plusieurs lignes. Dans ce cas, il faut penser à placer l’opérateur + en fin de ligne, afin que R comprenne que la commande n’est pas complète et qu’il prenne en compte la suite.

Pour simplifier un peu le code, plutôt que de déclarer les mappages dans chaque geom, on peut les déclarer dans l’appel à ggplot(). Ils seront automatiquement “hérités” par les geom ajoutés (sauf s’ils redéfinissent les mêmes mappages).

ggplot(rp, aes(x = departement, y = maison)) +
  geom_boxplot() +
  geom_jitter(color = "red", alpha = 0.2)

Autre exemple, on peut vouloir ajouter à un nuage de points une ligne de régression linéaire à l’aide de geom_smooth :

ggplot(rp, aes(x = dipl_sup, y = cadres)) +
  geom_point(alpha = 0.2) +
  geom_smooth(method = "lm")
`geom_smooth()` using formula = 'y ~ x'

Et on peut même superposer une troisième visualisation de la répartition des points dans l’espace avec geom_density2d :

ggplot(rp, aes(x = dipl_sup, y = cadres)) +
  geom_point(alpha = 0.2) +
  geom_density2d(color = "red") +
  geom_smooth(method = "lm")
`geom_smooth()` using formula = 'y ~ x'

Scales

On a vu qu’avec ggplot2 on définit des mappages entre des attributs graphiques (position, taille, couleur, etc.) et des variables d’un tableau de données. Ces mappages sont définis, pour chaque geom, via la fonction aes().

Les scales dans ggplot2 permettent de modifier la manière dont un attribut graphique sera relié aux valeurs d’une variable, et dont la légende correspondante va être affichée. Par exemple, pour l’attribut color, on pourra définir la palette de couleur utilisée. Pour size, les tailles minimales et maximales, etc.

Pour modifier une scale existante, on ajoute un nouvel élément à notre objet ggplot2 avec l’opérateur +. Cet élément prend la forme scale_<attribut>_<type>.

Voyons tout de suite un exemple

scale_x, scale_y

Les scales scale_x_<type> et scale_y_<type> modifient les axes x et y du graphique.

Continuous

scale_x_continuous et scale_y_continuous s’appliquent lorsque la variable x ou y est numérique (quantitative).

C’est le cas de notre nuage de points croisant part de cadres et part de diplômés du supérieur.

ggplot(rp) +
  geom_point(aes(x = dipl_sup, y = cadres))

Limits

Comme on représente des pourcentages, on peut vouloir forcer les axes x et y à s’étendre des valeurs 0 à 100. On peut le faire en ajoutant un élément scale_x_continuous et un élément scale_y_continuous, et en utilisant leur argument limits.

ggplot(rp) +
  geom_point(aes(x = dipl_sup, y = cadres)) +
  scale_x_continuous(limits = c(0,100)) +
  scale_y_continuous(limits = c(0,100))

Légende

Là aussi, on peut modifier les étiquettes des axes en indiquant une chaîne de caractères en premier argument.

ggplot(rp) +
  geom_point(aes(x = dipl_sup, y = cadres)) +
  scale_x_continuous("Part des diplômés du supérieur (%)", limits = c(0,100)) +
  scale_y_continuous("Part des cadres (%)", limits = c(0,100))

Autres scale_x_<type>

  • On utilise scale_x_log10 et scale_y_log10 pour passer un axe à une échelle logarithmique.
  • scale_x_discrete et scale_y_discrete s’appliquent lorsque l’axe correspond à une variable discrète (qualitative). C’est le cas par exemple de l’axe des x dans un diagramme en barres. L’argument limits de scale_x_discrete permet d’indiquer quelles valeurs sont affichées et dans quel ordre.

Ressources

La documentation officielle (en anglais) de ggplot2 est très complète et accessible en ligne.

Une “antisèche” (en anglais) résumant en deux pages l’ensemble des fonctions et arguments et disponible soit directement depuis RStudio (menu Help > Cheatsheets > Data visualization with ggplot2) ou en ligne.

Les parties Data visualisation et Graphics for communication de l’ouvrage en ligne R for data science, de Hadley Wickham, sont une très bonne introduction à ggplot2.

Plusieurs ouvrages, toujours en anglais, abordent en détail l’utilisation de ggplot2, en particulier ggplot2: Elegant Graphics for Data Analysis, toujours de Hadley Wickham, et le R Graphics Cookbook de Winston Chang.

Le site associé à ce dernier ouvrage comporte aussi pas mal d’exemples et d’informations intéressantes.

Enfin, si ggplot2 présente déjà un très grand nombre de fonctionnalités, il existe aussi un système d’extensions permettant d’ajouter des geom, des thèmes, etc. Le site ggplot2 extensions est une très bonne ressource pour les parcourir et les découvrir, notamment grâce à sa galerie.

Les références

Barnier, Julien, et Mayeul Kauffmann. 2023. « "Introduction à R et au tydiverse" ». Zenodo. https://doi.org/10.5281/zenodo.6382598.