« Introduction à la visualisation des données avec R » : différence entre les versions

De EduTech Wiki
Aller à la navigation Aller à la recherche
Ligne 393 : Ligne 393 :
</source>
</source>


En réalité, le seule paramètre qui est toujours obligatoire est le '''nom du fichier''' <code>filename = </code> avec lequel sauvegarder le graphique. Le nom du fichier peut se composer :
Le seule paramètre qui est toujours obligatoire est le '''nom du fichier''' <code>filename = </code> avec lequel sauvegarder le graphique. Le nom du fichier peut se composer :


* Seulement du nom du fichier et de l'extension, par exemple '''compare_book_vs_ebook.png''' ou '''compare_book_vs_ebook.svg'''. Dans ce cas, le fichier sera sauvegardé au même niveau de la ''working directory'' actuelle. L'extension choisi va d'ailleurs déterminer dans quel format sauvegarder l'image
* Seulement du nom du fichier et de l'extension, par exemple '''compare_book_vs_ebook.png''' ou '''compare_book_vs_ebook.svg'''. Dans ce cas, le fichier sera sauvegardé au même niveau de la ''working directory'' actuelle. L'extension choisi va d'ailleurs déterminer dans quel format sauvegarder l'image
Ligne 405 : Ligne 405 :
)
)
</source>
</source>
Par conséquent, la version la plus courte possible de la fonction serait la suivante :
<source lang="R">
ggsave(filename = "book-vs-ebook.png")
</source>
Comme vous pouvez le noter, cette invocation de la fonction n'utilise nul part la référence <code>compare_graphique</code> à laquelle nous avons associé notre graphique. Ceci s'explique par le fait que, sans aucune référence explicite avec le paramètre <code>plot =</code>, la fonction <code>ggsave()</code> sauvegarde le dernier objet disponible créé avec <code>ggplot()</code>, qui est accessible à travers la fonction <code>last_plot()</code>. Cet opération marche même si le graphique n'a pas été associé à une référence symbolique. Mais pour faciliter la lecture du code, nous conseillons d'indiquer explicitement quelle <code>plot</code> la fonction est en train de sauvegarder.


D'autres paramètres de la sauvegarde peuvent être définit, par exemple la largeur et l'hauteur, ainsi que l'unité de référence :
D'autres paramètres de la sauvegarde peuvent être définit, par exemple la largeur et l'hauteur, ainsi que l'unité de référence :
Ligne 425 : Ligne 417 :
)
)
</source>
</source>
À noter que vous pouvez parfois lire dans la documentation ou des tutoriels une version minimaliste de la fonction qui dans notre cas serait similaire à celle-ci :
<source lang="R">
ggsave("book-vs-ebook.png")
</source>
Comme vous pouvez le noter, cette invocation de la fonction n'utilise pas le nom du paramètre <code>filename</code>. En plus, la référence <code>compare_graphique</code> à laquelle nous avons associé notre graphique n’apparaît nul part. Ceci s'explique par le fait que, sans aucune référence explicite avec le paramètre <code>plot =</code>, la fonction <code>ggsave()</code> sauvegarde le dernier objet disponible créé avec <code>ggplot()</code>, qui est accessible à travers la fonction <code>last_plot()</code>. Cet opération marche même si le graphique n'a pas été associé à une référence symbolique. Mais pour faciliter la lecture du code, nous conseillons d'indiquer explicitement quelle <code>plot</code> la fonction est en train de sauvegarder.

Version du 11 mars 2020 à 15:57

Cet article est en construction: un auteur est en train de le modifier.

En principe, le ou les auteurs en question devraient bientôt présenter une meilleure version.



Introduction

L'une des utilisations les plus fréquentes de R concerne la création de visualizations des données à différents niveaux de complexité et pour différents objectifs. Notamment, on peut diviser les visualizations des données en deux grandes catégories :

  • Visualizations exploratoires, dont la finalité consiste principalement à mieux comprendre des données ;
  • Visualizations communicationnelles, dont la finalité est de synthétiser les résultats dans une forme graphique qui permet aux lecteurs de mieux les comprendre par rapport à des formes alternatives (e.g. texte ou tableau).

La flexibilité de R fait ainsi qu'on puisse utiliser les mêmes principes et outils pour les deux finalités et, de plus, d'intégrer directement les visualizations des données dans un flux de travail plus large, incluant notamment la génération de report scientifiques (voir à ce propos Introduction à Rmarkdown).

Prérequis

Aucune connaissance préalable n'est nécessaire pour suivre le contenu de cet article. Cependant, pour maximiser sa compréhension et la possibilité d'appliquer directement les éléments traités, les articles suivants peuvent être très utils :

De plus, même si les exemples proposés dans la page peuvent être reproduit dans tout environnement qui supporte R, l'utilisation de RStudio est conseillée, voir à ce propos :

Générer des visualizations des données avec du code

Il existe plusieurs possibilités pour générer des visualizations des données, comme par exemple en utilisant un logiciel d'analyse statistique (e.g. SPSS ou Jamovi), un logiciel de type spreadsheet (e.g. Excel), ou encore un logiciel consacré précisément à cette démarche (e.g. Tableau Software). L'utilisation de R dans ce contexte présente les avantages en termes de flexibilité, adaptabilité et réutilisation du code. Dans cette section, nous aborderons brièvement cet aspect : comment générer des visualizations de données avec du code ?

Fonctions graphiques

Le principe est assez simple une fois qu'on comprend la logique plus étendue d'un langage de programmation (voir Introduction conceptuelle à R) : il existe des procédures (ou fonctions) qui transforment des données en représentations graphiques. Voyons tout de suite un exemple de base :

1 # Générer aléatoirement 100 chiffres entre 1 et 100
2 simulated_data <- sample(1:10, size = 100, replace = TRUE)
3 
4 # Les afficher en histogramme
5 hist(simulated_data)

Ce code fait deux choses :

  1. À la ligne 2, nous créons 100 chiffres aléatoires entre 1 et 10 et nous les stockons avec la référence symbolique simulated_data
  2. À la ligne 4, nous utilisons la fonction hist() en lui passant en argument nos données à travers la référence symbolique que nous venons de créer : hist(simulated_data)

Le résultat (qui s'affiche dans le tab Plot si vous utilisez RStudio) sera similaire à l'image suivante :

Simple histogramme avec R

Utiliser des arguments pour adapter le graphique

Le principe de base vu dans le point précédent peut être complexifié en utilisant d'autres arguments dans la fonction qui permettent d'adapter le graphique selon les besoins :

1 # Adapter le graphique avec des arguments
2 hist(
3   simulated_data,
4   main = "Simulation de 100 données entre 1 et 10",
5   xlab = "Données simulées",
6   ylab = "Nombre d'occurence",
7   col = "lightblue",
8 )

La fonction hist() est la même, ainsi que son premier argument simulated_data. La fonction accepte également d'autres arguments, comme par exemple :

  1. Ligne 4 main = "Simulation de 100 données entre 1 et 10" modifie le titre du graphique
  2. Lignes 5 et 6 modifient respectivement la labellisation des axes x et y
  3. Ligne 7 col = "lightblue" modifie la couleur des colonnes du histogramme

Le résultat sera similaire à l'image suivante :

Histogramme avec définition de quelques options

Complexification du principe de base

R permet de créer une énorme variété de représentations graphiques, du simple au très complexe, que ce soit à travers des fonctions disponibles dans les paquets de base ou à travers des paquets externes. Dans tous les cas, il s'agit d'une complexification de cet exemple de base. Dès que les visualisations deviennent plus complexes, la création du code devient également plus articulée, ce qui requiert un effort de mémorisation (ou une référence à portée de main) pour se rappeler des noms de fonctions et arguments nécessaires. Néanmoins, cette approche permet une plus grande flexibilité ainsi que la possibilité de réutiliser ou adapter le code pour créer plusieurs représentations graphiques.

Nous pouvons par exemple complexifier l'exemple de base de la manière suivante :

 1 # Générer aléatoirement 100 chiffres entre 1 et 100
 2 simulated_data <- sample(1:10, size = 100, replace = TRUE)
 3 
 4 # Adapter le graphique avec des arguments
 5 hist(
 6   simulated_data,
 7   main = "Simulation de 100 données entre 1 et 10",
 8   xlab = "Données simulées",
 9   ylab = "Nombre d'occurence",
10   col = "lightblue",
11 )
12 
13 # Ajouter une ligne horizontale avec une valeur de 10
14 abline(h = 10, col="red", lwd=3, lty=2)
15 
16 # Ajouter une légende correspondante
17 legend(
18   x = "topright", 
19   c("Limite de 10"),
20   col = c("red"),
21   lwd = c(3),
22   lty = c(2)
23 )

Nous avons apporté les modifications suivantes :

  • À la ligne 14, avec la fonction abline(), nous avons ajouté une ligne horizontale en correspondance de la valeur 10. Cette ligne a des arguments qui en détermine la couleur col, la largeur lwd, et le type de trait lty;
  • De la ligne 17 à 23, nous avons ajouté une légende, avec certains arguments (en forme de vecteurs cette fois-ci) qui reprennent les arguments de la ligne horizontale.

Le résultat sera similaire à l'image suivante :

Histogramme avec fonctions supplémentaires

Comme vous pouvez le noter, certains arguments ne sont pas très saillants (e.g. lwd ou lty) et de plus ils sont associés à des chiffres. Il faudrait donc se souvenir à quel type de trait correspond le chiffre 1, le chiffre 2, etc.

D'autre côté, le fait qu'on puisse générer des graphiques à travers des fonctions permet de combiner les éléments de manière différente, par exemple à l'intérieur d'un paquet qui développe une syntaxe homogène. C'est le cas du paquet ggplot2 que nous introduisons dans la suite de cet article.

Présentation de ggplot2

Dans la suite de cet article, nous allons nous focaliser sur un paquet spécifique, appelé ggplot2, qui fait partie de l'écosystème Tidyverse. Ce paquet, développé à l'origine par Hadley Wickham (2016), implémente une grammaire des graphiques selon laquelle chaque graphique est le résultat de l'association de différentes composantes, qui peuvent se combiner de différentes manières, comme c'est le cas pour la grammaire des mots.

Installation

ggplot2 peut être installé de deux manières :

  1. En tant que paquet individuel :
    # Installation individuelle
    install.packages("ggplot2")
    
  2. Avec le paquet-écosystème de Tidyverse
    install.packages("tidyverse")
    

L'installation de l'écosystème Tidyverse est conseillé, car ggplot2 peut s'intégrer facilement avec d'autres manipulations sur les données comme selection, filtrage, agrégation, etc.

Principes de base de ggplot2

L'introduction à ggplot2 peut s'avérer assez complexe tout au début. Pour cette raison, nous allons d'abord expliquer deux concepts fondamentaux à la base de ggplot2, même avant de voir du code. Se souvenir de ces principes pourra être utile pour dépasser une certaine resistance initiale et voir les énormes avantages qui s'ouvrent avec l'utilisation d'une approche structurée à la création de représentations visuelles. Les deux principes de base sont :

  1. La notion de esthétique
  2. L'organisation en layers (ou niveaux)

La notion d'esthétique

Histogramme avec taille verticale des colonnes comme esthétique

Habituellement, l'esthétique se réfère aux propriétés graphiques générales d'un élément (sa couleur, taille, etc.). En ggplot2, cependant, ce terme est utilisé dans un contexte bien précis, c'est-à-dire lorsque ces mêmes propriétés graphiques sont déterminées directement par les données.

Prenons l'exemple de l'histogramme du point 2.2, dont l'image est proposée à nouveau sur la droite. Cette représentation visuelle présente plusieurs propriétés graphiques, mais nous allons nous focaliser sur deux en particulières :

  • La taille verticale des colonnes de l'histogramme est une esthétique
    La hauteur des colonnes est déterminée directement par les données simulées elles-mêmes. En d'autres termes, si on simule à nouveau d'autres données (ou si vous comparez votre propre graphique à celui que nous avons affiché), la taille verticale des colonnes va varier en fonction des nouvelles données simulées.
  • La couleur de remplissage des colonnes de l'histogramme n'est pas une esthétique
    Au contraire, la couleur de remplissage (le bleu clair) n'est pas déterminée par les données elles-mêmes, mais plutôt par un paramètre fixe dans le code. Les colonnes de l'histogramme seront toujours bleu clair, indépendamment des données simulées, à moins qu'on ne change pas la fonction qui génère l'histogramme.

Il est important de signaler, néanmoins, qu'il n'y aucun règle fixe qui détermine ce qui est une esthétique ou ce qui ne l'est pas. On peut notamment avoir un cas inverse par rapport à l'exemple précédent. Le graphique suivant affiche 3 simulations de 50 chiffres entre 1 et 5 en termes de proportion pour chaque tirage :

Histogramme avec couleur de remplissage comme esthétique

Comme vous pouvez le remarquez, ici :

  • La taille verticale des colonnes de l'histogramme n'est pas une esthétique
    Toutes les colonnes ont la même hauteur et cela indépendamment du nombre des chiffres simulées, car on est dans le contexte des proportions.
  • La couleur de remplissage des colonnes de l'histogramme est une esthétique
    Chaque colonne est divisée en 5 couleurs différents qui représentent la proportion de chaque chiffre entre 1 et 5. Dans ce cas, donc, la couleur représentent une sorte de double esthétique :
    1. Le type de couleur est déterminée par le groupe de chiffre, dans ce cas de 1 à 5, mais cela aurait pu être différent en fonction des données. Si on avait simulé un dé, donc avec 6 chiffres potentiels, le graphique présenterait 6 couleurs au lieu de 5.
    2. La taille verticale de la couleur est déterminée par la proportion de chiffres pour chaque groupe. Par exemple, on peut noter que dans la troisième simulation il y plus de chiffres 1 que dans la première et deuxième simulation, car la colonne rouge en haut de chaque colonne occupe une surface verticale plus grande.

En résumé :

Une esthétique identifie quelle(s) propriétée(s) graphique(s) d'une représentation visuelle sont déterminées en fonction des données elles-mêmes.

Il s'agit d'un principe fondamental, mais qui n'est pas immédiat. Par la suite de cette page, nous verrons plusieurs exemples concrets pour appliquer ce principe.

L'organisation en layers

Exemple de graphique avec différents layers

Un autre aspect fondamental de ggplot2 concerne l'organisation d'une représentation graphique sur plusieurs niveaux (ou layers) superposés. En effet, lorsqu'on regarde un graphique sur papier ou à l'écran, toutes les composantes sont aplaties en deux dimensions, même si en réalité les éléments ne se trouvent pas tous sur le même plan. On peut imaginer un graphique comme une combinaison d'éléments sur la même toile, un processus qui est sans doute familier pour ce qui ont une certaine expérience avec les logiciels de traitement d'image (e.g. Inkscape, Illustrator, ...).

ggplot2 exploite le concept de layer pour permettre une plus grande flexibilité dans la création de visualizations. Grâce à la superposition de layers, en effet, il est possible de combiner plusieurs représentations graphiques afin de véhiculer le plus d'information possible. Par exemple, le graphique sur la droite montre la comparaison entre trois conditions expérimentales. Sans compter les éléments corollaires (e.g. axes, légendes, ...), le graphique présente trois couches superposées :

  1. Les petits cercles semi-transparents représentent les différents participants et forment un scatterplot au niveau plus bas
  2. Le carré plein représente la moyenne de chaque condition expérimental
  3. Les deux bras représentent les intervalles de confiance à 95%

Ces éléments sont composés dans le même graphique selon un choix délibérée. On aurait pu enlever chacun de ces éléments ou les afficher avec une superposition différente. De cette manière, néanmoins, nous pouvons afficher à la fois les données brutes, pour avoir une idée du phénomène de la dispersion des données, ainsi que des indices de tendance centrale (moyenne) et de variabilité (intervalles de confiance).

ggplot2 utilise un système de superposition en layers qui permet de combiner, en fonction des besoins spécifiques, plusieurs éléments sur le même graphique.

Analyse d'un exemple de base

Après ce long préambule, il est temps de voir enfin du code ! Nous fournirons un example de base qui réplique l'histogramme créé avec les fonctions R de base pour mettre en évidence l'approche différente de ggplot2.

La première action à faire concerne le chargement du paquet ggplot2. Comme on a vu, on peut le faire de manière individuelle ou à travers le paquet global tidyverse. Nous allons utiliser d'autres fonctions de tidyverse dans l'exemple et par conséquent notre code commence avec :

1 library(tidyverse)

Ensuite, il faut être attentifs au fait que ggplot2 travaille exclusivement avec des structures des données de type data.frame ou tibble (voir Introduction à Tidyverse). Par conséquent, on ne peut pas utiliser un simple vecteur de chiffres comme nous l'avons fait pour l'exemple avec R de base : il faut le transformer. Dans ce cas, nous utilisons la fonction tibble() de tidyverse :

1 library(tidyverse)
2 
3 simulated_data <- tibble(
4   numbers = sample(1:10, size = 100, replace = TRUE)
5 )

Nous avons créé une structure de données appelée simulated_data qui consiste dans une seule colonne appelée numbers. Cette démarche a été nécessaire dans notre situation spécifique, mais dans la plupart des cas, les données qu'on utilise en Data Science sont déjà en format data.frame ou tibble, donc ce passage ne sera pas nécessaire. Cependant, il est utile à indiquer que ggplot2 peut être utilisé seulement avec un format de données spécifique.

Une fois que notre structure de données est conforme aux attentes de ggplot2, nous pouvons enfin utiliser le paquet pour créer le graphique :

1 library(tidyverse)
2 
3 simulated_data <- tibble(
4   numbers = sample(1:10, size = 100, replace = TRUE)
5 )
6 
7 ggplot(data = simulated_data, mapping = aes(x = numbers)) +
8   geom_histogram(fill = "blue")

Les lignes qui nous intéressent sont les lignes 7 et 8.

À la ligne 7, nous utilisons d'abord la fonction ggplot(). Il s'agit de la fonction de base, nécessaire pour créer un graphique. Cette fonction accepte plusieurs paramètres, mais dont deux sont les plus importants :

  1. data fait référence à la structure de données à représenter, dans notre cas le tibble simulated_data
  2. mapping fait référence à l'association entre les données et les propriétés graphiques, c'est-à-dire le principe de esthétique que nous avons vu plus haut. En effet, on associe à l'argument mapping la fonction aes() (abbreviation de aesthetics en anglais). Cette fonction accepte une liste d'associations clé = valeur dans laquelle :
    • La clé correspond à la propriété graphique concernée. Dans notre cas, il s'agit de l'axe x ou nous allons afficher les différentes colonnes de l'histogramme
    • La valeur correspond aux données spécifiques que nous voulons afficher. Dans notre cas, il s'agit des chiffres contenus dans la colonne numbers de la structure des données simulated_data

La ligne 7 se termine avec le + qui peut être interprété comme le principe des layers décrit plus haut : on ajoute un élément ultérieur au graphique. Faites bien attention que avant le + il faut fermes deux parenthèses : une pour la fonction principale ggplot(), et l'autres pour la fonction aes() imbriquée. Oublier une parenthèse arrive assez souvent, donc si vous obtenez un message d'erreur, c'est l'une des éléments à contrôler.

La ligne 8 geom_histogram(fill = "blue") introduit une famille de fonctions qui sont caractérisées par le préfix geom_. Il s'agit des fonctions qui permettent de créer différents types de graphique et se réfèrent au principe de geom, qu'on peut traduire par forme. Il existe plusieurs type de geom, comme par exemple geom_point() pour un scatterplot, geom_boxplot() pour une boîte à moustache, etc.

Dans notre cas, nous souhaitons un histogramme, et par conséquent nous utilisons la fonction geom_histogramme(). Cette fonction accepte encore une fois plusieurs paramètres possibles. Ici nous en spécifions le paramètres fill = "blue" pour déterminer la couleur des colonnes de l'histogramme. Ceci nous permet de renforcer la distinction entre une esthétique déterminée par les données, et une propriété graphique qui est fixée par un choix. Ici la couleur des colonnes est fixée, par conséquent il ne faut pas utiliser la fonction aes().

Voici le graphique qui résulte de ce code (la taille des colonnes peut varier en fonction de la génération aléatoire des chiffres dans votre script) :

Premier exemple de graphique avec ggplot2

Cet exemple de base peut être complexifié de differentes manières. Nous proposons ici quelques éléments supplémentaires. Plutôt que tous les expliquer, il peut-être plus utile d'essayer directement de modifier certains paramètres pour voir les changements sur le graphique et comprendre ainsi leur utilité :

 7 ggplot(data = simulated_data, mapping = aes(x = numbers)) +
 8   geom_histogram(fill = "blue") +
 9   geom_hline(yintercept = 10, color = "red", linetype = 2, size = 2) +
10   labs(
11     x = "Données simulées",
12     y = "Nombre d'occurrences",
13     title = "Simulation de 100 données entre 1 et 10"
14   ) +
15   scale_x_continuous(breaks = 1:10) +
16   scale_y_continuous(breaks = 1:15) +
17   theme_minimal()
Variante de l'exemple de base avec code supplémentaire

Syntaxe abrégée de la fonction ggplot()

Étant donnée que les paramètres data et mapping de la fonction ggplot() sont déterminants - et par conséquent utilisés presque toujours - vous pouvez souvent lire dans des tutoriels ou dans la documentation un format abrégé de la fonction, sans les noms des paramètres :

1 # Syntaxe complète
2 ggplot(data = simulated_data, mapping = aes(x = numbers)) +
3   geom_histogram(fill = "blue")
4 
5 # Syntaxe abrégée
6 ggplot(simulated_data, aes(x = numbers)) +
7   geom_histogram(fill = "blue")

Avec ce type de syntaxe, il est fondamental de respecter l'ordre des paramètres : d'abord la structure des données, et ensuite la fonction aes() pour déterminer les esthétiques du graphique.

Dans un processus d'apprentissage, l'utilisation de la version complète peut favoriser une compréhension procédurale des éléments récurrents à la plupart des graphiques. Avec la pratique, en revanche, on a plutôt la tendance à éliminer tout ce qui n'est pas strictement nécessaire. Idéalement, les exemples contenus dans cette page utilisent la syntaxe complète, mais il peut y avoir également des exemples avec syntaxe abrégée, dont l'utilisation est d'ailleurs prévalente.

Références symboliques aux graphiques

Un avantage dérivant de l'utilisation de ggplot2 consiste dans la possibilité d'associer des graphiques (ou parties de graphiques) à des références symboliques. De cette manière, les graphiques peuvent être maniés et réutilisés à travers la référence symbolique.

 1 library(tidyverse)
 2 
 3 simulated_data <- tibble(
 4   numbers = sample(1:10, size = 100, replace = TRUE)
 5 )
 6 
 7 # Associer une première partie du graphique à une référence symbolique
 8 simple_version <- ggplot(data = simulated_data, mapping = aes(x = numbers)) +
 9   geom_histogram(fill = "blue")
10 
11 # Réutiliser la référence pour ajouter d'autres éléments
12 complexified_version <- simple_version +
13   geom_hline(yintercept = 10, color = "red", linetype = 2, size = 2) +
14   labs(
15     x = "Données simulées",
16     y = "Nombre d'occurrences",
17     title = "Simulation de 100 données entre 1 et 10"
18   ) +
19   scale_x_continuous(breaks = 1:10) +
20   scale_y_continuous(breaks = 1:15) +
21   theme_minimal()

Attention : lorsqu'on associe un graphique à une référence symbolique, l'exécution du code n'affiche pas automatiquement le résultat dans le tab "Plot" de RStudio. Pour afficher le graphique vous avez deux possibilités :

  1. Saisir le nom de la référence symbolique dans la console, e.g. simple_version
  2. Entourer le bloc de code avec des parenthèses :
    (simple_version <- ggplot(data = simulated_data, mapping = aes(x = numbers)) +
      geom_histogram(fill = "blue"))
    

Sauvegarder un graphique

ggplot2 est particulièrement indiqué dans le cadre de la génération automatique de document (voir Introduction à Rmarkdown). Néanmoins, il est également possible de sauvegarder le output des graphes en différents formats matriciels (.png, .jpg, .pdf, ...) ou vectoriels. Le format vectoriel SVG, notamment, permet éventuellement de modifier ultérieurement le graphique, par exemple dans le contexte de la physicalisation de données.

Il existe deux manières différentes pour sauvegarder une représentation visuelle : manuellement, ou - idéalement - directement à travers le code, donc automatiquement.

Sauvegarde manuelle

La manière la plus simple pour sauvegarder un graphique manuellement est à travers le tab Plot de l'interface de RStudio qui permet de sauvegarder toutes les représentations visuelles, non seulement celles créées avec ggplot2. Le bouton Export permet de :

  1. Sauvegarder le graphique en tant que image en plusieurs formats
  2. Sauvegarder le graphique en tant que PDF
  3. Copier le graphique pour pouvoir le coller directement dans un logiciel de traitement de texte ou de présentation

Si on choisit d'exporter le graphique en tant que image, une nouvelle fenêtre modale s'affiche à l'écran :

Exporter un graphique à travers l'interface de RStudio

À travers cette fenêtre modale on peut choisir :

  • Le format de l'image (e.g. .png, .jpg, .svg, ...)
  • Le dossier dans lequel sauvegarder le fichier
  • Le nom à donner au fichier
  • Hauteur et largeur de l'image
La sauvegarde manuelle peut être utile pour exporter rapidement des graphiques d'exemple, mais dans la plupart des cas, c'est mieux d'adopter la bonne pratique de la sauvegarde automatisée.

Sauvegarde automatisée

La sauvegarde automatisée d'un graphique consiste à écrire une instruction à travers le code qui sauvegarde la représentation visuelle dans un fichier. Ce fichier sera automatiquement mise à jour à chaque exécution du code et par conséquent le fichier va refléter toujours la toute dernière version du graphique (e.g. changement de couleurs, titres des axes, thème, ...), sans avoir à la sauvegarder manuellement à chaque modification.

La sauvegarde de représentations graphiques créés avec ggplot2 se fait à travers la fonction ggsave(). Cette fonction sauvegarde une représentation graphique par rapport au dossier de travail (i.e. working directory) actuel de R :

  • Si vous utilisez un projet RStudio, la working directory est la racine du projet (voir également Premier projet avec RStudio)
  • Si vous utilisez RStudio, mais non un projet, vous pouvez voir votre working directory affichée en haut du panneau de la Console
  • Dans tous le cas, vous pouvez connaître votre working directory avec la commande getwd()

Pour changer la working directory, nous conseillons à des utilisateurs novices de R de créer un projet en RStudio.

Une fois contrôlé votre dossier de travail, vous pouvez utiliser la fonction ggsave() de différentes manières. Pour les illustrer, nous allons d'abord fournir un simple code pour créer des données simulées à utiliser pour créer un graphique :

 1 library(ggplot2)
 2 
 3 # Simulation de données sur les heures de lecture livre papier vs. e-book
 4 sim_data <- tibble(
 5   condition = sample(c("book", "e-book"), size = 200, replace = TRUE),
 6   hours_reading = rnorm(200, mean = 100, sd = 15)
 7 )
 8 
 9 # Créer un graphique qui compare les données groupées par condition et l'associer à une référence symbolique
10 compare_graphique <- ggplot(sim_data, aes(x = condition, y = hours_reading, color = condition)) +
11   geom_jitter(alpha = 0.3) +
12   labs(
13     x = NULL,
14     y = "Heures passées à lire"
15   ) +
16   theme_bw() +
17   theme(
18     legend.position = "none"
19   )

Une fois le graphique disponible, la fonction ggsave() peut être configurée à travers un nombre variable de paramètres, dont les plus importants sont :

  • filename : nom du fichier à donner
  • plot : quel représentation graphique sauvegarder

Dans notre cas, donc, la fonction pour sauvegarder notre représentation graphique pourrait être celle-ci :

ggsave(filename = "book-vs-ebook.png", plot = compare_graphique)

Le seule paramètre qui est toujours obligatoire est le nom du fichier filename = avec lequel sauvegarder le graphique. Le nom du fichier peut se composer :

  • Seulement du nom du fichier et de l'extension, par exemple compare_book_vs_ebook.png ou compare_book_vs_ebook.svg. Dans ce cas, le fichier sera sauvegardé au même niveau de la working directory actuelle. L'extension choisi va d'ailleurs déterminer dans quel format sauvegarder l'image
  • Ajouter un chemin relatif (ou absolu, mais cette option est déconseillée) avant le nom du fichier et l'extension, par exemple figures/compare_book_vs_ebook.png. Dans ce cas, le sous-dossier figures doit être déjà disponible dans la working directory actuelle.
    • En alternative au nom composé du fichier, vous pouvez aussi utiliser le paramètre path. À ce moment, vous explicitez seulement le nom du fichier dans filename :
      ggsave(
        filename = "compare_book_vs_ebook.png", 
        plot = compare_graphique, 
        path = "figures"
      )
      

D'autres paramètres de la sauvegarde peuvent être définit, par exemple la largeur et l'hauteur, ainsi que l'unité de référence :

ggsave(
  filename = "book-vs-ebook_16_9.png", 
  plot = compare_graphique,
  width = 16,
  height = 9,
  units = "cm"
)

À noter que vous pouvez parfois lire dans la documentation ou des tutoriels une version minimaliste de la fonction qui dans notre cas serait similaire à celle-ci :

ggsave("book-vs-ebook.png")

Comme vous pouvez le noter, cette invocation de la fonction n'utilise pas le nom du paramètre filename. En plus, la référence compare_graphique à laquelle nous avons associé notre graphique n’apparaît nul part. Ceci s'explique par le fait que, sans aucune référence explicite avec le paramètre plot =, la fonction ggsave() sauvegarde le dernier objet disponible créé avec ggplot(), qui est accessible à travers la fonction last_plot(). Cet opération marche même si le graphique n'a pas été associé à une référence symbolique. Mais pour faciliter la lecture du code, nous conseillons d'indiquer explicitement quelle plot la fonction est en train de sauvegarder.