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

De EduTech Wiki
Aller à la navigation Aller à la recherche
Aucun résumé des modifications
(47 versions intermédiaires par le même utilisateur non affichées)
Ligne 3 : Ligne 3 :
== Introduction ==
== 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 :
L'une des utilisations les plus fréquentes de [[R]] concerne la création de visualisations des données à différents niveaux de complexité et pour différents objectifs. Notamment, on peut diviser les visualisations des données en deux grandes catégories :


* Visualizations exploratoires, dont la finalité consiste principalement à mieux comprendre des données ;
* '''Visualisations 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).
* '''Visualisations 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]]).
De plus, les deux types de visualisations peuvent être '''''statiques''''' ou '''''dynamiques/interactives'''''. Les représentations statiques sont les plus répandues dans les contributions scientifiques. Néanmoins, certains visualisations plus complexes peuvent bénéficier d'interactivité, comme par exemple la possibilité de zoomer sur une partie du graphique, mettre en évidence une observation spécifique parmi toutes les observations affichés, etc.
 
La flexibilité de [[R]] fait ainsi qu'on puisse utiliser les mêmes principes et outils pour les deux finalités et dans les deux modalités (statique ou interactive). De plus, les visualisations peuvent être intégrées directement dans un flux de travail plus large, incluant notamment la génération de report scientifiques (voir à ce propos [[Introduction à Rmarkdown]]) ou des pages web à publier.
 
Dans cet article nous proposons un introduction général à la visualisation des données à travers un langage de programmation, ce qui comporte une approche différente par rapport aux logiciels de type ''point-and-click''. Nous utiliserons des exemples du paquet '''graphics''' qui est disponible par défaut en [[R]] afin de pouvoir tester les exemples rapidement, sans installer des paquets supplémentaires. En revanche, ce paquet est plus difficile à utiliser par rapport à des paquets externes plus récents et puissants, dont nous proposons une liste non exhaustive dans l'article.


=== Prérequis ===
=== Prérequis ===
Ligne 22 : Ligne 26 :
* {{ Goblock | [[Mise en place d'un environnement de travail avec R]] }}
* {{ Goblock | [[Mise en place d'un environnement de travail avec R]] }}


== Générer des visualizations des données avec du code ==
== Générer des visualisations 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 ?
Il existe plusieurs possibilités pour générer des visualisations 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 visualisations de données avec du code ? À titre d'exemple, nous utiliserons des fonctions du paquet '''graphics''' qui est disponible par défaut avec [[R]]. Les exemples disponibles dans cette section peuvent donc être testé directement, sans l'installation d'autres paquets supplémentaires.


=== Fonctions graphiques ===
=== Fonctions graphiques ===
Ligne 41 : Ligne 45 :


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


Le résultat (qui s'affiche dans le tab '''Plot''' si vous utilisez [[RStudio]]) sera similaire à l'image suivante :
Le résultat (qui s'affiche dans le tab '''Plot''' si vous utilisez [[RStudio]]) sera similaire à l'image suivante :
Ligne 115 : Ligne 119 :
Comme vous pouvez le noter, certains arguments ne sont pas très saillants (e.g. <code>lwd</code> ou <code>lty</code>) 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.  
Comme vous pouvez le noter, certains arguments ne sont pas très saillants (e.g. <code>lwd</code> ou <code>lty</code>) 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 [https://ggplot2.tidyverse.org/ ggplot2] que nous introduisons dans la suite de cet article.
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 comme [[Visualisation des données avec ggplot2|ggplot2]].
 
== ggplot2 ==
 
Dans la suite de cet article, nous allons nous focaliser sur un paquet spécifique, appelé [https://ggplot2.tidyverse.org/ ggplot2], qui fait partie de l'écosystème [[Introduction à Tidyverse|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 :
 
# En tant que paquet individuel :
#: <source lang="R">
# Installation individuelle
install.packages("ggplot2")
</source>
#:
# Avec le paquet-écosystème de [[Introduction à Tidyverse|Tidyverse]]
#: <source lang="R">
install.packages("tidyverse")
</source>
 
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 ===
== Anatomie computationnelle d'un graphique ==


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 :
Au niveau computationnel, un graphique est le résultat de la combinaison entre données d'Input et instructions qui s'occupent de déterminer les détails spécifique de l'Output. Nous proposons donc d'analyser un graphique en fonction du schéma de base '''Input-Computation-Output''' qui est commun à l'ensemble des ressources de la [[pensée computationnelle avec R]].


# La notion de '''esthétique'''
=== Format de Input ===
# L'organisation en '''layers''' (ou niveaux)


==== La notion d'esthétique ====
En utilisant des fonctions pour générer des représentations visuelles, il faut déterminer le format d'Input qui est adéquat à la fonction. La décision du format d'entrée dépend des créateurs des fonctions ou paquets de [[R]] qui s'occupent de générer les représentations graphiques, car il n'y a pas de standard universel. Par exemple, les fonctions disponibles ''out-of-the-box'' dans [[R]] acceptent généralement des vecteurs ; d'autres paquets plus récents, comme [[Visualisation des données avec ggplot2|ggplot2]], requièrent des formats rectangulaires (e.g., data.frame) ; d'autres paquets encore peuvent nécessiter des formats avec des structures multi-dimensionnelles comme dans le format [[JSON]].


[[Fichier:R-histogramme-height-as-aes.png|300px|vignette|droite|Histogramme avec taille verticale des colonnes comme esthétique]]
D'ailleurs, certains fonctions acceptent ou requièrent des Inputs différents par rapport à des structures des données, comme par exemples des modèles (voir [[Introduction à la modélisation des données avec R]]). La fonction <code>plot()</code> du paquet de base '''graphics''' en est un exemple :
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 :
 
[[Fichier:R-histogramme-color-as-aes.png|600px|vignette|néant|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 :
*# 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.
*# 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é :
 
{{ bloc important | 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 ====
 
[[Fichier:Ggplot2-different-layers.svg|400px|vignette|droite|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 :
 
# Les petits cercles semi-transparents représentent les différents participants et forment un scatterplot au niveau plus bas
# Le carré plein représente la moyenne de chaque condition expérimental
# 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).
 
{{ bloc important | 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 :


<source lang="R" line>
<source lang="R" line>
library(tidyverse)
# Données fictives
</source>
fict_data <- data.frame(
 
  minutes_running = c(45, 20, 55, 0, 15, 90, 120, 15, 0, 0, 15, 30),
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 <code>tibble()</code> de tidyverse :
   hours_sleeping = c(5.5, 4.5, 6.5, 4.5, 7, 8, 5, 4, 4, 6, 7, 8)
 
<source lang="R" line>
library(tidyverse)
 
simulated_data <- tibble(
   numbers = sample(1:10, size = 100, replace = TRUE)
)
)
</source>
Nous avons créé une structure de données appelée <code>simulated_data</code> qui consiste dans une seule ''colonne'' appelée <code>numbers</code>. 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 :


<source lang="R" line highlight="7,8">
# Plot avec les colonnes du data.frame pour scatterplot
library(tidyverse)
plot(
 
  x = fict_data$minutes_running,
simulated_data <- tibble(
   y = fict_data$hours_sleeping,
   numbers = sample(1:10, size = 100, replace = TRUE)
  xlab = "Running minutes per day",
  ylab = "Sleeping hours per day"
)
)


ggplot(data = simulated_data, mapping = aes(x = numbers)) +
# Modèle de regréssion linéaire sur les données du data.frame
  geom_histogram(fill = "blue")
lm.model <- lm(hours_sleeping ~ minutes_running, data = fict_data)
</source>
 
Les lignes qui nous intéressent sont les lignes 7 et 8.
 
À la ligne 7, nous utilisons d'abord la fonction <code>ggplot()</code>. 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 :
# <code>data</code> fait référence à la structure de données à représenter, dans notre cas le ''tibble'' <code>simulated_data</code>
# <code>mapping</code> 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 <code>mapping</code> la fonction <code>aes()</code> (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 <code>x</code> 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 <code>numbers</code> de la structure des données <code>simulated_data</code>
 
La ligne 7 se termine avec le <code>+</code> 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 <code>+</code> il faut fermes deux parenthèses : une pour la fonction ''principale'' <code>ggplot()</code>, et l'autres pour la fonction <code>aes()</code> 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 <code>geom_histogram(fill = "blue")</code> introduit une famille de fonctions qui sont caractérisées par le préfix <code>geom_</code>. 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 <code>geom_point()</code> pour un scatterplot, <code>geom_boxplot()</code> pour une boîte à moustache, etc.
# Disposer 2 graphique par ligne
 
par(mfrow = c(2,2))
Dans notre cas, nous souhaitons un histogramme, et par conséquent nous utilisons la fonction <code>geom_histogramme()</code>. Cette fonction accepte encore une fois plusieurs paramètres possibles. Ici nous en spécifions le paramètres <code>fill = "blue"</code> 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 <code>aes()</code>.
# Afficher les graphiques
 
plot(lm.model)
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) :
 
[[Fichier:Ggplot2-premier-exemple.svg|600px|vignette|néant|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é :
 
<source lang="R" line start = 7>
ggplot(data = simulated_data, mapping = aes(x = numbers)) +
  geom_histogram(fill = "blue") +
  geom_hline(yintercept = 10, color = "red", linetype = 2, size = 2) +
  labs(
    x = "Données simulées",
    y = "Nombre d'occurrences",
    title = "Simulation de 100 données entre 1 et 10"
  ) +
  scale_x_continuous(breaks = 1:10) +
  scale_y_continuous(breaks = 1:15) +
  theme_minimal()
</source>
</source>


[[Fichier:Ggplot2-variante-premier-exemple.svg|600px|vignette|néant|Variante de l'exemple de base avec code supplémentaire]]
La fonction <code>plot(...)</code> des lignes 8 à 13 créent un ''simple'' scatterplot en utilisant les données du data.frame fictif :


==== Syntaxe abrégée de la fonction ggplot() ====
[[Fichier:R scatterplot avec plot.png|400px|vignette|néant|Scatterplot généré avec la fonction <code>plot()</code>]]


Étant donnée que les paramètres <code>data</code> et </code>mapping</code> de la fonction <code>ggplot()</code> 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 :
La fonction <code>plot(lm.model)</code> de la ligne 21, par contre, affiche 4 graphiques souvent utilisés pour évaluer les postulats d'une regression linéaire (affichés en deux lignes et deux colonnes grâce à la fonction <code>par(mfrow = c(2,2))</code> de ligne 19) :


<source lang="R" line highlight = "2,6">
[[Fichier:R graphiques multiples pour regression.png|400px|vignette|néant|4 graphiques utilisés dans l'évaluation des postulats dans une regression linéaire, générés avec la même fonction <code>plot()</code>]]
# Syntaxe complète
ggplot(data = simulated_data, mapping = aes(x = numbers)) +
  geom_histogram(fill = "blue")
 
# Syntaxe abrégée
ggplot(simulated_data, aes(x = numbers)) +
  geom_histogram(fill = "blue")
</source>


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 <code>aes()</code> pour déterminer les esthétiques du graphique.  
Ce n'est pas important de comprendre les détails ni du modèle de regression, ni des graphiques. Le message à retenir concerne la possibilité de passer en Input autre chose que des données à une fonction qui crée des représentations graphiques.


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.
=== Computation d'une représentation visuelle ===


=== Références symboliques aux graphiques ===
En utilisant des logiciels ''point-and-click'' qui créent des graphiques grâce à des manipulations plus ou moins imposées, on peut facilement sous-estimer la computation qui est déclenchée lors de la création d'une représentation graphique. En fonction de la complexité du graphique et des données d'Input, des calculs sont effectués par exemple pour :


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.
* '''Transformer les données en formes et éléments graphiques'''
*: Les données sont associées avec des propriétés graphiques telles que la position, la couleur, l'opacité, la taille, etc. La computation d'un graphique doit donc implémenter concrètement ces associations.
* '''Agréger des données'''
*: L'un des avantages des graphiques comparé aux données brutes ou à un tableau consiste à créer des patterns, comme par exemple des regroupements ou des séparations, qui véhiculent de l'information. Sur le même graphique, il est possible de combiner plusieurs agrégation de données à la fois.
* '''Créer des indices et références visuelles'''
*: Pour faciliter la compréhension de l'information, les graphiques affichent souvent des éléments supplémentaires qui aident à mieux cerner les données, comme par exemple les légendes ou les unités des axes.
* '''Adapter le contenu aux limites du ''canvas'''''
*: Le graphique occupe un espace - à l'écran ou sur papier - limité, une sorte de ''toile'' (ou en termes plus techniques, un ''canvas''). L'ensemble de l'information affiché par le graphique doit donc être ajusté afin que tout puisse être contenu dans les limites du ''canvas''.


<source lang="R" line highlight=12>
=== Format de Output ===
library(tidyverse)


simulated_data <- tibble(
La computation du graphique peut aboutir à différents formats de Output qui peuvent différer en fonction du support nécessaire pour les visualiser, leur finalité, ou encore leur extension temporaire. Nous pouvons identifier les formats d'Output suivants :
  numbers = sample(1:10, size = 100, replace = TRUE)
)


# Associer une première partie du graphique à une référence symbolique
* Une '''[[image matricielle]]'''
simple_version <- ggplot(data = simulated_data, mapping = aes(x = numbers)) +
*: Ce type d'image est composé de pixels individuel, dont la couleur de chaque pixel détermine l'affichage globale de l'image. Dans ce contexte, [[R]] s'occupe de déterminer comment ''colorer'' les pixels qui font partie de la représentation visuelle et de les mettre à disposition à travers une image matricielle, dont les extensions les plus fréquentes sont <code>.png</code> ou <code>.jpg</code>.
  geom_histogram(fill = "blue")
* Une '''[[image vectorielle]]''' ou '''dessin vectoriel'''
*: Ce type de graphique est déterminé à travers de formules mathématiques qui déterminent l'affichage de patterns qui compose le dessin. Dans ce contexte, [[R]] s'occupe de déterminer les formules qui représentent les différents éléments qui composent le graphique et les mettre à disposition à travers une image vectorielle, dont le format le plus utilisé est [[SVG]], avec extension <code>.svg</code>.
* Une '''animation'''
*: Une animation est créé à travers la succession de différents images qui varient progressivement l'une de l'autre afin de provoquer dans le système visuel l'illusion du mouvement. Une description technique d'une animation est disponible dans la page [[Animation avec JavaScript]]. Même s'il s'agit d'un langage différent, les concepts techniques sont les mêmes.
* Une '''représentation visuelle interactive'''
*: Type de représentation qui permet aux utilisateurs de modifier l'affichage en fonction de leurs actions. Les représentations visuelles interactives sont en général rendues disponibles à travers des pages web, donc avec du [[HTML5]], [[CSS]] et [[JavaScript]]. La transposition se fait en général automatiquement, donc une connaissance de ces éléments n'est pas nécessaire, mais peut néanmoins s'avérer utile pour des modifications ou intégration dans des contextes plus articulés (e.g. sites web). Une description technique de l'interactivité est disponible dans la page [[Interactivité avec JavaScript]]. Le langage est différent, mais les concepts restent les mêmes.


# Réutiliser la référence pour ajouter d'autres éléments
Les représentations visuelles peuvent être enregistrées en tant que fichier (ou ensemble de fichiers), ou intégrées directement dans un document à travers la syntaxe [[Introduction à Rmarkdown|Rmarkdown]]. Cette deuxième possibilité est particulièrement utile, car elle permet d'adapter les graphiques et disposer toujours de la dernière version du graphique dans le document finale. Pour plus d'informations, voir [[Introduction à Rmarkdown]].
complexified_version <- simple_version +
  geom_hline(yintercept = 10, color = "red", linetype = 2, size = 2) +
  labs(
    x = "Données simulées",
    y = "Nombre d'occurrences",
    title = "Simulation de 100 données entre 1 et 10"
  ) +
  scale_x_continuous(breaks = 1:10) +
  scale_y_continuous(breaks = 1:15) +
  theme_minimal()
</source>


'''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 :
== Paquets de R pour la visualisation des données ==


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


=== Sauvegarder un graphique ===
Le paquet [[Visualisation des données avec ggplot2|ggplot2]] est l'un des paquets les plus utilisés, non seulement dans le contexte académique. Par exemple, la [https://bbc.github.io/rcookbook/ BBC] (télévision britannique) utilise ce paquet avec un thème graphique personnalisé pour ces représentations graphiques. ggplot2 fait partie de l'écosystème [[Introduction à Tidyverse|Tidyverse]] et est basé sur une grammaire des graphiques qui visent à décomposer les graphiques en différents composantes qui peuvent être déclinés et combinés de différentes manières. Il perment de créer principalement des représentations graphiques statiques, mais qui peuvent définir dynamiques ou interactives grâce à un large écosystème d'extensions et paquets qui l'intègrent. Pour plus d'infos voir :


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 [[image matricielle|matriciels]] (.png, .jpg, .pdf, ...) ou [[image vectorielle|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]].
* {{ Goblock | [[Visualisation des données avec ggplot2]] }} sur ce wiki
* [https://ggplot2.tidyverse.org/ Site officiel du paquet]
* [https://exts.ggplot2.tidyverse.org/ Extensions de ggplot2]
* [https://ggplot2-book.org/ ggplot2: Elegant Graphics for Data Analysis]


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


==== Sauvegarde manuelle ====
=== highcharter ===


La manière la plus simple pour sauvegarder un graphique manuellement est à travers le tab ''Plot'' de l'interface de [[RStudio]]. Le bouton '''Export''' permet de :
=== lattice ===


# Sauvegarder le graphique en tant que '''image''' en plusieurs formats
=== RGL ===
# Sauvegarder le graphique en tant que '''PDF'''
# 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 :
=== DiagrammeR ===


[[Fichier:Ggplot2-export-image.png|600px|vignette|néant|Exporter un graphique à travers l'interface de [[RStudio]]]]
=== Leaflet ===


À travers cette fenêtre modale on peut choisir :
== Conclusion ==


* Le format de l'image (e.g. .png, .jpg, [[SVG|.svg]], ...)
== Ressources ==
* Le dossier dans lequel sauvegarder le fichier
* Le nom à donner au fichier
* Hauteur et largeur de l'image


{{bloc important | 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.}}
* [https://r-graphics.org/ R Graphics Cookbook, 2nd edition] collection de plus de 150 ''recettes'' pour la visualisation de données avec R
* [https://clauswilke.com/dataviz/ Fundamentals of Data Visualization] de Claus O. Wilke


==== Sauvegarde automatisée ====
[Catégorie:R]]

Version du 24 mai 2022 à 13:51

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 visualisations des données à différents niveaux de complexité et pour différents objectifs. Notamment, on peut diviser les visualisations des données en deux grandes catégories :

  • Visualisations exploratoires, dont la finalité consiste principalement à mieux comprendre des données ;
  • Visualisations 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).

De plus, les deux types de visualisations peuvent être statiques ou dynamiques/interactives. Les représentations statiques sont les plus répandues dans les contributions scientifiques. Néanmoins, certains visualisations plus complexes peuvent bénéficier d'interactivité, comme par exemple la possibilité de zoomer sur une partie du graphique, mettre en évidence une observation spécifique parmi toutes les observations affichés, etc.

La flexibilité de R fait ainsi qu'on puisse utiliser les mêmes principes et outils pour les deux finalités et dans les deux modalités (statique ou interactive). De plus, les visualisations peuvent être intégrées directement dans un flux de travail plus large, incluant notamment la génération de report scientifiques (voir à ce propos Introduction à Rmarkdown) ou des pages web à publier.

Dans cet article nous proposons un introduction général à la visualisation des données à travers un langage de programmation, ce qui comporte une approche différente par rapport aux logiciels de type point-and-click. Nous utiliserons des exemples du paquet graphics qui est disponible par défaut en R afin de pouvoir tester les exemples rapidement, sans installer des paquets supplémentaires. En revanche, ce paquet est plus difficile à utiliser par rapport à des paquets externes plus récents et puissants, dont nous proposons une liste non exhaustive dans l'article.

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 visualisations des données avec du code

Il existe plusieurs possibilités pour générer des visualisations 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 visualisations de données avec du code ? À titre d'exemple, nous utiliserons des fonctions du paquet graphics qui est disponible par défaut avec R. Les exemples disponibles dans cette section peuvent donc être testé directement, sans l'installation d'autres paquets supplémentaires.

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 5, 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 comme ggplot2.

Anatomie computationnelle d'un graphique

Au niveau computationnel, un graphique est le résultat de la combinaison entre données d'Input et instructions qui s'occupent de déterminer les détails spécifique de l'Output. Nous proposons donc d'analyser un graphique en fonction du schéma de base Input-Computation-Output qui est commun à l'ensemble des ressources de la pensée computationnelle avec R.

Format de Input

En utilisant des fonctions pour générer des représentations visuelles, il faut déterminer le format d'Input qui est adéquat à la fonction. La décision du format d'entrée dépend des créateurs des fonctions ou paquets de R qui s'occupent de générer les représentations graphiques, car il n'y a pas de standard universel. Par exemple, les fonctions disponibles out-of-the-box dans R acceptent généralement des vecteurs ; d'autres paquets plus récents, comme ggplot2, requièrent des formats rectangulaires (e.g., data.frame) ; d'autres paquets encore peuvent nécessiter des formats avec des structures multi-dimensionnelles comme dans le format JSON.

D'ailleurs, certains fonctions acceptent ou requièrent des Inputs différents par rapport à des structures des données, comme par exemples des modèles (voir Introduction à la modélisation des données avec R). La fonction plot() du paquet de base graphics en est un exemple :

 1 # Données fictives
 2 fict_data <- data.frame(
 3   minutes_running = c(45, 20, 55, 0, 15, 90, 120, 15, 0, 0, 15, 30),
 4   hours_sleeping = c(5.5, 4.5, 6.5, 4.5, 7, 8, 5, 4, 4, 6, 7, 8)
 5 )
 6 
 7 # Plot avec les colonnes du data.frame pour scatterplot
 8 plot(
 9   x = fict_data$minutes_running, 
10   y = fict_data$hours_sleeping,
11   xlab = "Running minutes per day",
12   ylab = "Sleeping hours per day"
13 )
14 
15 # Modèle de regréssion linéaire sur les données du data.frame
16 lm.model <- lm(hours_sleeping ~ minutes_running, data = fict_data)
17 
18 # Disposer 2 graphique par ligne
19 par(mfrow = c(2,2))
20 # Afficher les graphiques
21 plot(lm.model)

La fonction plot(...) des lignes 8 à 13 créent un simple scatterplot en utilisant les données du data.frame fictif :

Scatterplot généré avec la fonction plot()

La fonction plot(lm.model) de la ligne 21, par contre, affiche 4 graphiques souvent utilisés pour évaluer les postulats d'une regression linéaire (affichés en deux lignes et deux colonnes grâce à la fonction par(mfrow = c(2,2)) de ligne 19) :

4 graphiques utilisés dans l'évaluation des postulats dans une regression linéaire, générés avec la même fonction plot()

Ce n'est pas important de comprendre les détails ni du modèle de regression, ni des graphiques. Le message à retenir concerne la possibilité de passer en Input autre chose que des données à une fonction qui crée des représentations graphiques.

Computation d'une représentation visuelle

En utilisant des logiciels point-and-click qui créent des graphiques grâce à des manipulations plus ou moins imposées, on peut facilement sous-estimer la computation qui est déclenchée lors de la création d'une représentation graphique. En fonction de la complexité du graphique et des données d'Input, des calculs sont effectués par exemple pour :

  • Transformer les données en formes et éléments graphiques
    Les données sont associées avec des propriétés graphiques telles que la position, la couleur, l'opacité, la taille, etc. La computation d'un graphique doit donc implémenter concrètement ces associations.
  • Agréger des données
    L'un des avantages des graphiques comparé aux données brutes ou à un tableau consiste à créer des patterns, comme par exemple des regroupements ou des séparations, qui véhiculent de l'information. Sur le même graphique, il est possible de combiner plusieurs agrégation de données à la fois.
  • Créer des indices et références visuelles
    Pour faciliter la compréhension de l'information, les graphiques affichent souvent des éléments supplémentaires qui aident à mieux cerner les données, comme par exemple les légendes ou les unités des axes.
  • Adapter le contenu aux limites du canvas
    Le graphique occupe un espace - à l'écran ou sur papier - limité, une sorte de toile (ou en termes plus techniques, un canvas). L'ensemble de l'information affiché par le graphique doit donc être ajusté afin que tout puisse être contenu dans les limites du canvas.

Format de Output

La computation du graphique peut aboutir à différents formats de Output qui peuvent différer en fonction du support nécessaire pour les visualiser, leur finalité, ou encore leur extension temporaire. Nous pouvons identifier les formats d'Output suivants :

  • Une image matricielle
    Ce type d'image est composé de pixels individuel, dont la couleur de chaque pixel détermine l'affichage globale de l'image. Dans ce contexte, R s'occupe de déterminer comment colorer les pixels qui font partie de la représentation visuelle et de les mettre à disposition à travers une image matricielle, dont les extensions les plus fréquentes sont .png ou .jpg.
  • Une image vectorielle ou dessin vectoriel
    Ce type de graphique est déterminé à travers de formules mathématiques qui déterminent l'affichage de patterns qui compose le dessin. Dans ce contexte, R s'occupe de déterminer les formules qui représentent les différents éléments qui composent le graphique et les mettre à disposition à travers une image vectorielle, dont le format le plus utilisé est SVG, avec extension .svg.
  • Une animation
    Une animation est créé à travers la succession de différents images qui varient progressivement l'une de l'autre afin de provoquer dans le système visuel l'illusion du mouvement. Une description technique d'une animation est disponible dans la page Animation avec JavaScript. Même s'il s'agit d'un langage différent, les concepts techniques sont les mêmes.
  • Une représentation visuelle interactive
    Type de représentation qui permet aux utilisateurs de modifier l'affichage en fonction de leurs actions. Les représentations visuelles interactives sont en général rendues disponibles à travers des pages web, donc avec du HTML5, CSS et JavaScript. La transposition se fait en général automatiquement, donc une connaissance de ces éléments n'est pas nécessaire, mais peut néanmoins s'avérer utile pour des modifications ou intégration dans des contextes plus articulés (e.g. sites web). Une description technique de l'interactivité est disponible dans la page Interactivité avec JavaScript. Le langage est différent, mais les concepts restent les mêmes.

Les représentations visuelles peuvent être enregistrées en tant que fichier (ou ensemble de fichiers), ou intégrées directement dans un document à travers la syntaxe Rmarkdown. Cette deuxième possibilité est particulièrement utile, car elle permet d'adapter les graphiques et disposer toujours de la dernière version du graphique dans le document finale. Pour plus d'informations, voir Introduction à Rmarkdown.

Paquets de R pour la visualisation des données

ggplot2

Le paquet ggplot2 est l'un des paquets les plus utilisés, non seulement dans le contexte académique. Par exemple, la BBC (télévision britannique) utilise ce paquet avec un thème graphique personnalisé pour ces représentations graphiques. ggplot2 fait partie de l'écosystème Tidyverse et est basé sur une grammaire des graphiques qui visent à décomposer les graphiques en différents composantes qui peuvent être déclinés et combinés de différentes manières. Il perment de créer principalement des représentations graphiques statiques, mais qui peuvent définir dynamiques ou interactives grâce à un large écosystème d'extensions et paquets qui l'intègrent. Pour plus d'infos voir :

Plotly

highcharter

lattice

RGL

DiagrammeR

Leaflet

Conclusion

Ressources

[Catégorie:R]]