2.1 Grammaire graphique

Le principe de base derrière la grammaire graphique (d’où le gg dans ggplot) est qu’un graphique statistique est une représentation de données, dans un système de coordonnées spécifique, divisée en éléments de base :

• éléments géométriques (geoms) : points, lignes, barres, etc.;
• propriétés visuelles (aesthetics) des éléments géométriques : axes, couleurs, formes, tailles, etc.
• transformations statistiques, si désiré : courbe de régression ou de lissage, région d’erreur, etc.

Un graphique est spécifié en associant des variables, provenant des données, à des propriétés visuelles des éléments géométriques du graphique. Ces principes sont représentés comme suit sur la feuille de triche officielle du package.

Source : https://github.com/rstudio/cheatsheets/blob/master/data-visualization-2.1.pdf

2.2 Principales fonctions et gabarit de code

Les principales fonctions du package ggplot2 sont les suivantes :

• ggplot : initialisation d’un objet de classe ggplot;
• qplot : initialisation rapide (q pour quick) d’un objet ggplot;
• + : opérateur pour l’ajout de couches ou la modification de configurations dans un objet ggplot;
• fonctions de type geom_* (p. ex. geom_point, geom_boxplot, geom_bar, etc.) : spécification de couches à ajouter à un graphique;
• aes : création d’un mapping, soit une association entre entre des propriétés visuelles et des variables;
• ggsave : enregistrement d’un graphique.

Notons que l’utilisation de la fonction qplot est plus intuitive que celle de ggplot pour des gens familiers avec plot. La fonction qplot n’offre cependant pas toutes les possibilités de ggplot. Elle ne sera pas couverte dans ce document.

Voici un gabarit minimaliste de code de création d’un graphique ggplot2 (source : http://r4ds.had.co.nz/data-visualisation.html#a-graphing-template) :

ggplot(data = <DATA>) + 
  <GEOM_FUNCTION>(mapping = aes(<MAPPINGS>))

ou encore la version « tout sur la même ligne » :

ggplot(data = <DATA>) + <GEOM_FUNCTION>(mapping = aes(<MAPPINGS>))

Dans ce gabarit, il faut remplacer les éléments entre < et > comme suit :

• <DATA> = jeu de données, stocké dans un data frame (ou un tibble), dans lequel les variables catégoriques doivent être des facteurs (dont les libellés des niveaux ont avantage à être informatifs, car ils apparaîtront dans le graphique);
• <GEOM_FUNCTION> = le nom d’une fonction de type geom_* pour ajouter une couche au graphique;
• <MAPPINGS> = arguments à fournir à la fonction aes (les arguments acceptés varient un peu selon la <GEOM_FUNCTION>).

Voici un premier exemple simple.

ggplot(data = quakes) + geom_point(mapping = aes(x = mag, y = stations))

Les arguments data et mapping peuvent être fournis :

• à la fonction ggplot : leur valeur est alors commune à toutes le couches
  (il est tout de même possible de forcer l’utilisation d’autres données ou d’autres associations pour des couches spécifiques);
• ou à une <GEOM_FUNCTION> : leur valeur est alors spécifique à la couche produite.

Étant donné que le graphique produit par le gabarit minimaliste ne comprend qu’une seule couche, les syntaxes suivantes sont donc équivalentes à celle du gabarit.

# Argument data spécifique (fourni dans l'appel à la <GEOM_FUNCTION>)
ggplot() + <GEOM_FUNCTION>(data = <DATA>, mapping = aes(<MAPPINGS>))

# Argument mapping global (fourni dans l'appel à ggplot)
ggplot(data = <DATA>, mapping = aes(<MAPPINGS>)) + <GEOM_FUNCTION>()

2.3 Objet de classe ggplot

Un graphique produit en ggplot2 est en fait un objet de classe ggplot. La fonction ggplot initialise un objet de cette classe.

mon_graph <- ggplot(data = quakes)

Nous pouvons ajouter des couches à un objet ggplot avec l’opérateur +.

mon_graph <- mon_graph + geom_point(mapping = aes(x = mag, y = stations))

Il est possible d’observer le contenu de l’objet.

str(mon_graph)  # non évalué, car la sortie est longue

summary(mon_graph)

## data: lat, long, depth, mag, stations, mag_catego, region [1000x7]
## faceting: <ggproto object: Class FacetNull, Facet, gg>
##     compute_layout: function
##     draw_back: function
##     draw_front: function
##     draw_labels: function
##     draw_panels: function
##     finish_data: function
##     init_scales: function
##     map_data: function
##     params: list
##     setup_data: function
##     setup_params: function
##     shrink: TRUE
##     train_scales: function
##     vars: function
##     super:  <ggproto object: Class FacetNull, Facet, gg>
## -----------------------------------
## mapping: x = ~mag, y = ~stations 
## geom_point: na.rm = FALSE
## stat_identity: na.rm = FALSE
## position_identity

C’est en affichant une objet de classe ggplot qu’un graphique est produit.

mon_graph # ou print(mon_graph)

La fonction ggsave permet quant à elle d’enregistrer un graphique ggpot2.

ggsave(file = "ExempleGraphique_ggplot2.pdf", plot = mon_graph)

Le format du fichier à créer (p. ex. PDF, PNG, EPS, etc.) est déduit de l’extension du fichier si l’argument device n’est pas spécifié. Aussi, si aucune valeur n’est fourni à l’argument plot, c’est le dernier graphique ggpot2 produit qui est enregistré. La dimension du graphique enregistré peut être contrôlée à l’aide des arguments width, height et units.

2.4 Démarche de création d’un graphique ggplot2

Voici une suggestion de démarche à suivre lors de la création d’une graphique ggplot2.

1. Planifier le travail - Répondre aux questions suivantes :
   1. Je veux représenter quelles variables, de quel jeu de données ?
   2. Je veux créer quel type de graphique ?
   3. Quelle fonction de type geom_* me permettra de produire les éléments géométriques de ce graphique ?
   4. Cette fonction accepte quelles propriétés visuelles ? (voir http://ggplot2.tidyverse.org/reference/)
   5. Je veux associer les variables concernées à quelles propriétés visuelles ?
2. Écrire et soumettre la première version du code de création du graphique.
3. Modifier le code de création du graphique pour ajuster la mise en forme (titre, nom d’axes, autres annotations, palette de couleur, etc.) selon mes besoins,
   • travail itératif : cycle « modification code » \(\rightarrow\) « jugement du graphique créé » répété jusqu’à l’obtention d’un résultat satisfaisant.

La planification effectuée avant de produire le premier exemple de graphique ggplot pourrait être représentée comme suit.

Pour réaliser cette planification, il a fallu obtenir de la fiche d’aide de la fonction geom_point la liste des propriétés visuelles qu’elle accepte.

3.1 Exemples de configurations graphiques simples

ggplot(data = quakes) + 
  geom_point(mapping = aes(x = mag, y = stations)) +
  labs(
    title = "1000 séismes près de Fidji",          # ou ggtitle("...") +
    x = "magnitude du séisme",                     # ou xlab("...") +
    y = "nombre de stations rapportant le séisme"  # ou ylab("...")
  )

ggplot(data = quakes) + 
  geom_point(mapping = aes(x = mag, y = stations)) +
  labs(
    title = "1000 séismes près de Fidji",
    x = "magnitude du séisme",
    y = "nombre de stations rapportant le séisme"
  ) +
  theme(plot.title = element_text(hjust = 0.5))  # permet de centrer le titre

scatterplot <- ggplot(data = quakes) + 
  geom_point(mapping = aes(
    x = mag, 
    y = stations, 
    colour = depth  # permet de faire varier la couleur des points en fonction de depth
  )) +
  labs(
    title = "1000 séismes près de Fidji",
    x = "magnitude du séisme",
    y = "nombre de stations rapportant le séisme",
    colour = "profondeur"  # permet de modifier le titre de la légende
  ) +
  theme(plot.title = element_text(hjust = 0.5)) +
  scale_colour_viridis_c()       # permet d'utiliser la palette de couleur viridis

scatterplot

scatterplot + 
  facet_wrap(facets = ~ region)   # permet de créer un sous-graphique par niveau de la variable region

scatterplot +
  facet_grid(mag_catego ~ region)  # ou facet_grid(rows = vars(mag_catego), cols = vars(region))

scatterplot +
  facet_grid(mag_catego ~ factor(region))

# Création d'un vecteur faisant office de « lookup table », contenant l'association entre 
# - les niveaux d'un facteur (nom des éléments dans le vecteur) et
# - leurs étiquettes à afficher dans le graphique (éléments du vecteur)
mag_catego_labels <- c(
  "4" = "mag 4",
  "5" = "mag 5",
  "6" = "mag 6"
)
# Production du graphique
scatterplot +
  facet_grid(
    mag_catego ~ region, 
    labeller = labeller(mag_catego = mag_catego_labels)
  )

3.2 Exemples de graphiques de différents types

Voici quelques exemples faisant intervenir divers types de graphiques, pour illustrer des possibilités de ggplot2. Si vous souhaitez voir encore plus d’exemples de code de création de graphique avec ggplot2, le web en regorge. Je recommande particulièrement la ressource suivante :

• https://evamaerey.github.io/ggplot_flipbook/ggplot_flipbook_xaringan.html#1

Il s’agit d’un flipbook très instructif, qui permet de visualiser l’impact de chaque petit ajout au code de création du graphique.

ggplot(data = quakes) + 
  geom_bar(mapping = aes(x = mag_catego)) +
  labs(
    x = "classe de magnitude du séisme",
    y = "fréquences"
  )  

quakes_mag <- as.data.frame(xtabs(~ mag_catego, data = quakes))
quakes_mag

##   mag_catego Freq
## 1          4  802
## 2          5  193
## 3          6    5

ggplot(data = quakes_mag) + 
  geom_col(mapping = aes(x = mag_catego, y = Freq)) +  # aesthetic y ajoutée
  coord_flip() +                               # permet d'inverser les axes
  labs(
    x = "classe de magnitude du séisme",
    y = "fréquences"
  ) 

ggplot(data = quakes, mapping = aes(x = mag_catego)) + # aesthetics communs ici
  geom_bar() +
  geom_text(
    mapping = aes(label = after_stat(count)),          # texte ajouté = fréquences
    colour = "blue",
    stat = "count",                                    # calcul des fréquences demandé ici 
    vjust = -0.2                                       # ajustement vertical
  ) +
  labs(
    x = "classe de magnitude du séisme",
    y = "fréquences"
  ) 

ggplot(data = quakes) + 
  geom_bar(mapping = aes(x = mag_catego, fill = region)) +  # aesthetic fill ajoutée
  labs(
    x = "classe de magnitude du séisme",
    y = "fréquences",
    fill = "région"
  ) 

ggplot(data = quakes) + 
  geom_bar(
    mapping = aes(x = mag_catego, fill = region), 
    position = "dodge"                             # position des bâtons modifiée
  ) +
  labs(
    x = "classe de magnitude du séisme",
    y = "fréquences",
    fill = "région"
  ) 

ggplot(data = quakes) + 
  geom_bar(
    mapping = aes(
      x = mag_catego, 
      y = after_stat(prop),  # permet le calcul de fréquences relatives (proportions)
      group = region,        # pour avoir les fréq. relatives de mag conditionnelles à region
      fill = region), 
    position = "dodge"
  ) +
  labs(
    title = "Proportions de séismes par classe de magnitude selon la région",
    x = "classe de magnitude du séisme",
    y = "fréquences",
    fill = "région"
  ) 

ggplot(data = quakes) +
  geom_bar(mapping = aes(x = 1, fill = mag_catego)) +
  coord_polar(theta = "y") +                           # coordonnées polaires
  theme_void() +                                       # thème vide
  labs(fill = "classe de\nmagnitude")

ggplot(data = quakes) + 
  geom_density(
    mapping = aes(x = mag, fill = region), 
    alpha = 0.5  # niveau d'opacité (0 = transparent, 1 = complètement opaque)
  ) +
  labs(
    x = "magnitude du séisme",
    y = "densité",
    fill = "région"
  )

violinplots <- ggplot(data = quakes) + 
  geom_violin(mapping = aes(x = region, y = mag)) +
  labs(
    x = "région",
    y = "magnitude du séisme"
  )

violinplots

boxplots <- ggplot(data = quakes) + 
  geom_boxplot(mapping = aes(x = region, y = mag)) +
  labs(
    x = "région",
    y = "magnitude du séisme"
  )

boxplots

3.3 Exemples divers plus poussés

ggplot(data = quakes) + 
  geom_jitter(                             # geom_jitter est utilisé au lieu de geom_point
    mapping = aes(x = mag, y = stations),
    colour = "blue", 
    alpha = 0.3
  ) +
  labs(
    title = "1000 séismes près de Fidji",
    x = "magnitude du séisme",
    y = "nombre de stations rapportant le séisme"
  )

ggplot(
  data = quakes, 
  mapping = aes(x = mag, y = stations)              # aesthetics communs placées ici
) +
  stat_density_2d(                                  # ajout de l'estimation de densité 2D
    aes(fill = after_stat(density)),
    geom = "tile",
    contour = FALSE
  ) +
  geom_point(
    shape = 20,                                     # pour modifier le symbole des points
    colour = "dodgerblue4"
  ) +
  labs(
    title = "1000 séismes près de Fidji",
    x = "magnitude du séisme",
    y = "nombre de stations rapportant le séisme",
    fill = "densité"
  ) +
  scale_fill_gradient(                              # pour modifier l'échelle de couleur
    low = "white", 
    high = "dodgerblue3"
  ) +  
  theme_classic()                                   # pour avoir rapidement un fond blanc

# Statistique dont nous aurons besoin
moy <- mean(quakes$mag)
et <- sd(quakes$mag)

histogramme <- ggplot(data = quakes, mapping = aes(x = mag)) + 
  geom_histogram(
    mapping = aes(y = after_stat(density)), 
    binwidth = 0.1, 
    colour = "black", 
    fill = "white"
  ) +
  labs(
    title = "Densité empirique des magnitudes dans le jeu de données quakes",
    x = "magnitude du séisme",
    y = "densité"
  )
  
histogramme + stat_function(           # ajout d'une courbe de densité normale 
    fun = dnorm, 
    args = list(mean = moy, sd = et),  # avec paramètres estimés à partir des données
    xlim = c(3.95, 6.45)
  )

histogramme +
  geom_density() +  # ajout d'une courbe d'estimation de densité à noyau
  stat_function(    # ajout d'une courbe de densité normale
    fun = dnorm, 
    args = list(mean = moy, sd = et),
    xlim = c(3.95, 6.45)
  )

histogramme <- histogramme +
  geom_density(
    aes(colour = "density"),  # association de la propriété visuelle colour à une valeur
  ) +
  stat_function(
    aes(colour = "dnorm"),    # association de la propriété visuelle colour à une valeur
    fun = dnorm, 
    args = list(mean = moy, sd = et),
    xlim = c(3.95, 6.45)
  )
histogramme

histogramme + scale_colour_manual(
    name = "",                                        # pour retirer le titre de la légende
    values = c("density" = "blue", "dnorm" = "red"),  # pour modifier les couleurs
    labels = c(                                       # pour modifier les étiquettes
      "density" = "Densité à noyau", 
      "dnorm" = expression(paste("N(", mu, " = ", bar(x), ", ", sigma^2, " = ",  s[x]^2, ")"))
    )
  )

histogramme + scale_colour_manual(
    name = "",
    values = c("density" = "blue", "dnorm" = "red"),
    labels = c("density" = "Densité à noyau", "dnorm" = "Densité normale") 
  ) +
  theme(
    legend.position = "top",           # modification de la position de la légende
    legend.background = element_rect(  # ajout d'une bordure rectangulaire autour de la légende
      size = 0.5, linetype = "solid", colour = "black"
    )
  )

4.1 Le tidyverse

Le package ggplot2 est souvent utilisé conjointement à d’autres packages du tidyverse, notamment :

• dplyr pour la manipulation / le prétraitement de données;
• magrittr qui offre l’opérateur « pipe » %>%;
• forcats pour la manipulation de facteurs.

library(dplyr)

quakes %>%
  filter(region == "Ouest") %>%
  ggplot(mapping = aes(x = mag, y = stations)) +
  geom_jitter(colour = "blue", alpha = 0.3) +
  labs(
    title = "Séismes dans la région Ouest",
    x = "magnitude du séisme",
    y = "nombre de stations rapportant le séisme"
  )

library(forcats)
region_reorder <- fct_reorder(
  .f = quakes$region, 
  .x = quakes$mag, 
  .fun = median
)
str(region_reorder)

##  Factor w/ 2 levels "Est","Ouest": 1 1 1 1 1 1 2 1 1 1 ...

ggplot(data = quakes) + 
  geom_boxplot(mapping = aes(
    x = fct_reorder(.f = region, .x = mag, .fun = median), 
    y = mag
  )) +
  labs(x = "région") +
  labs(y = "magnitude du séisme")

4.2 Extensions

Un nombre important d’extensions de ggplot2 sont offertes. Plusieurs sont énumérées sur le site web suivant : https://exts.ggplot2.tidyverse.org/gallery/

Voici une liste d’extensions intéressantes qui ont été le sujet d’un tutoriel réalisé par d’anciens étudiants de ces cours. Des exemples d’utilisation des ces packages peuvent être visualisés dans les tutoriels.

• ggrepel : fonction geom_text_repel pour éviter les textes superposés
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/ggrepel_ggthemes_paletteer/
• ggthemes : thèmes complets supplémentaires
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/ggrepel_ggthemes_paletteer/
• cowplot : thème adapté aux publications scientifiques et possibilité de combiner plusieurs graphiques en un
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2019/cowplot/
• patchwork : combinaison facile de plusieurs graphiques en un
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/patchwork_ggextra/
• ggExtra : fonction ggMarginal pour l’ajout facile d’histogrammes marginaux
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/patchwork_ggextra/
• gganimate : gif animés (ou autres formats d’animation)
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/gganimate/
• ggiraph : graphiques ggplot interactifs (format HTML)
  • tutoriel : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2018/ggiraph/

4.3 Cartes géographiques

Comme avec le système graphique de base, le package maps permet d’ajouter une carte en arrière-plan d’un graphique ggplot. Voici un exemple d’utilisation d’une carte tirée du package maps avec ggplot2 :

library(maps)
monde <- map_data("world")  # va chercher des données provenant du package maps
ggplot() + 
  geom_polygon(
    data = monde,
    aes(x = long, y = lat, group = group), 
    fill = "gray90", 
    col = "black"
  ) +
  geom_point(
    data = quakes, 
    aes(x = long, y = lat, colour = depth), 
    alpha = .3
  ) +
  coord_quickmap(           # ou coord_map() si le package mapproj est installé
    xlim = c(115, 190),  
    ylim = c(-50, 0)
  ) +
  labs(x = "longitude", y = "latitude", colour = "profondeur") +
  theme_bw()

L’extension ggmap permet également d’intégrer une carte Google Maps (requière un compte sur https://cloud.google.com/maps-platform/ pour avoir accès aux cartes) ou Stamen Maps à un graphique produit avec ggplot2.

Références :

• https://ggplot2-book.org/maps.html
• http://eriqande.github.io/rep-res-web/lectures/making-maps-with-R.html